Planeta PythonBrasil

PythonBrasil[9]

October 21, 2014

Magnun Leno

Hack ‘n’ Cast v0.7 - O.P.A.

Hoje, dia 21 de Outubro, está sendo instituído o dia do podcast e, para comemorar, estamos lançando um episódio extra (e por que não especial) do Hack 'n' Cast. Como todos sabemos, ouvir podcast se torna um vício, então resolvemos criar um grupo de ajuda e apoio para os que são afligidos por este mal.

Baixe o episódio e leia o shownotes

por Magnun em 21 de October de 2014 às 02:21

October 16, 2014

Eric Hideki

screenshot

#4 Danilo Bellini | Pythonistas que você devia conhecer

O Danilo é um cara que tem projetos sensacionais, um dos que mais me impressiona é o Audiolazy, projeto do qual foi elaborado para a defesa do seu mestrado. E o convido hoje para falar dele e de outros também muito bacanas.

Danilo, fale um pouco sobre você.

Que coisa mais difícil de responder…dizer apenas “um pouco sobre você” serve?

Vou dividir a resposta em tópicos que talvez sejam menos densos, e espero poder entreter o leitor ao invés de fazer disto apenas um curriculum chato e burocrático. O que segue enfatiza explicitamente assuntos voltados ao desenvolvimento de software.

Música

Sou um guitarrista que gosta de metal melódico/progressivo e diversos outros gêneros musicais. Ando com munhequeiras e caveiras, e já tive cabelo bastante longo:

Certo, o instrumento no vídeo não é lá muito parecido com uma guitarra…mas quem se importa? Tem cordas! Continuei deixando o cabelo crescer, e um ano depois desse vídeo, eu o doei:

#4 Danilo Bellini | Pythonistas que você devia conhecer
Doação do cabelo para a ASCCI

Lembro de ter visto a teoria musical básica (notas, partituras, durações, etc.) por volta dos 7 anos de idade, mas somente comecei com a guitarra no início de 2001, já com 15 anos de idade (denunciei minha idade =P), por conta do violão que foi levado ao primeiro dia de aula no colégio por um colega de classe, Arthur. Passei por diversas bandas/grupos musicais, normalmente como guitarrista ou tecladista. Fiz desde covers de bandas como Iron Maiden, Guns N’ Roses, Rhapsody, Helloween, Iced Earth, Djavan e Saltimbancos (com direito a um coral de crianças!), a bandas com músicas próprias como Fenrir, Avattar e Ravenland. Também participei de diversos corais como o Coral da ECA, o Coral da Poli, os 3 corais e camerata do Conservatório Beethoven e o coral do Studio Meyer.

000_0225
Preparando a apresentação com o Epic Tales, cover do Rhapsody, no Café Aurora (São Paulo) em 2004

OLYMPUS DIGITAL CAMERA
Participação tocando flauta doce com o Avantasians, cover do Avantasia, no Blackmore Rock Bar (São Paulo) em 2007

Foto Danilo (Fenrir)
Foto durante ensaio da Avattar com 3 integrantes do Fenrir

IMG_3583
Apresentação do Coral da ECA no MASP em 2009, cantando Carmina Burana de Carl Orff

Desenvolvimento de software até o fim do ensino médio/técnico – Jogos/Games!

Por outro lado, comecei com programação quando ainda tinha 1 dígito de idade, no momento em que meu pai disse que eu poderia criar meus próprios jogos (games) se aprendesse a programar. Embora tenha iniciado com coisas como Basic, Pascal, Visual Basic e Delphi, foi o Klik & Play, um software voltado à criação de jogos, que me manteve nessa direção. Somente em 1999, lembro que decidi parar de usar o Klik & Play, ano em que “retornei” para as linguagens “tradicionais” de programação, de início escrevendo “LuckBone”, um jogo de dominó usando BGI no Turbo Pascal para o DOS para 1 jogador. Isso tudo me trouxe grande interesse e ênfase em processamento gráfico, interatividade, inteligência artificial, roteiro, entre outros aspectos técnicos e “humanos”, embora eu talvez não soubesse onde procurar informação sobre isso tudo na época. Eu já tinha algum interesse por áudio, no sentido de efeitos para ações realizadas em jogos, mas seu processamento ainda não era minha ênfase.

LuckBone

LuckBone, jogo de dominó feito em 1999 com Turbo Pascal (DOS) e BGI, rodando no Linux via DOSBox, 593 linhas de código

No ano 2000 entrei no ensino médio/técnico em informática, especificamente no Colégio Singular, e pela primeira (e única) vez eu saí do sistema público de ensino. Gostei muito daquela época, aquele foi um local onde os valores de meus colegas foram não idênticos, mas pelo menos próximos aos meus em diversos aspectos, tanto técnicos como musicais. Jogos (não apenas games) marcaram essa época, desde cards como “Magic: The Gathering” e Pokémon a games como Warcraft II e horas em LAN Houses com Counter Strike, e até esportes físicos. Embora eu tenha a impressão de que não se tratava de algo tão valorizado no curso técnico, desenvolvi outros games para as exposições da “ExpoInfo” do colégio, por exemplo uma versão minha de clássicos como pacman (com gráficos feitos pelo Guilherme Seligra Lopes) e nibbles. Durante o colégio pude notar uma evidente inclinação a assuntos associados a imagens e jogos, além de ter conhecido nessa época softwares como o Corel Draw e visto um pouco de desenvolvimento web “estático” (eu tive uma página na GeoCities!).

O terceiro ano do colégio (ensino médio/técnico) eu realizei em simultâneo com o cursinho extensivo do Anglo, como bolsista (eu pagava somente o material por conta da minha média geral no colégio), e desde então as simultaneidades de atividades não pararam. 2002 foi também o ano de decidir que carreira escolher no vestibular…tenso! Ao dizer “música”, digamos apenas que o contexto social em que eu me encontrava não aprovou minha ideia. Algo similar ocorreu quando eu disse “matemática”, minha segunda ideia. Seguidamente, entre as opções “engenharia” e “ciência da computação”, fiquei com a primeira por conta do interesse em entender como as coisas funcionavam na prática, seja no assembly ou no hardware diretamente, e também por ter, na época, uma impressão [parcialmente] errônea sobre o que viria a ser o curso de ciência da computação. Certamente essa opinião foi influenciada pelo “choque” das primeiras aulas de “Linguagem de Programação” (segundo ano do colégio), em que era normativa a realização de fluxogramas (com régua específica) antes do código (em pseudo-código Pascal-like), ou ao estudar COBOL e fazer prova da linguagem com papel “retangularizado” para contar espaços de indentação, sem nunca colocar tal código em um computador para ver a coisa funcionar. Sei que houve grandes mudanças no curso já no ano seguinte ao meu (não calcule há quanto tempo terminei o colégio!), mas sem dúvidas vale dizer que quem aprende já desenvolvendo em Python tem a sorte de não precisar passar por essas coisas velhas e antiquadas, hoje posso dizer que já vi muito código em Python mais simples que pseudo-código.

Eletrônica e os passos até a primeira graduação

Arame de amarrar saco de pão e durex foi o material do meu primeiro hardware hack, feito em um modem da U.S. Robotics que havia parado de funcionar, mas que voltou a funcionar após esse hack. Eu literalmente curtei alguns componentes SMD no esquema “acho que o modem não precisa disto aqui para funcionar”, não me perguntem por que funcionou, eu provavelmente vou responder algo como “era óbvio, mas agora já não lembro mais”. Não me olhe com essa cara, eu soldei depois, e funcionou! =)

Meu pai havia comprado um material de eletrônica, daqueles que vendem em bancas de jornal periodicamente, e eu tentei fazer alguns dos experimentos, embora a ausência de ferramentas e de orientação/supervisão tenha sido claramente um impeditivo. Algo motivador para mim foi o uso que tive de um simples simulador de diagramas digitais em software, chamado EasySim, no qual eu podia simular circuitos com LEDs, portas lógicas, flip-flops e displays de 7 segmentos de uma maneira bastante intuitiva.

EasySim_Somador_2005

No final de 2002 e início de 2003, entre as provas da primeira e segunda fase do vestibular da Fuvest, eu precisei mudar. Foi com a prova da primeira fase da Fuvest que eu descobri uma falha no modelo de ensino/aprendizado que eu estava adotando, e substituí da maneira mais incisivamente que consegui a repetição pela “entropia”: li o material teórico inteiro das disciplinas de matemática, física e química ao invés de “perder tempo” fazendo exercícios sobre assuntos que eu já conhecia, trocando isso pela tentativa de realizar os exemplos do texto antes da solução dos mesmos, além de tentar deduzir equacionamentos, por exemplo jogando fora confusas “regras de três” para usar equações derivadas da própria unidade daquilo que eu estava usando. Acho que posso dizer que funcionou, isso fez eu ver até mesmo coisas como derivadas e leis de Kirchhoff antes de entrar na graduação, apesar de eu não ter visto no colégio parte significativa da matéria do ensino médio pelo fato de eu ter seguido o curso técnico. Fui com meus pais à praia nesse período, e lá estava eu à beira da praia, ou estudando uma apostila gigante de química, ou desenhando circuitos de resistores na areia.

Posteriormente me tornei, pela USP, engenheiro eletricista, bacharel em música e mestre em ciência da computação, em que os dois últimos cursos foram realizados em simultâneo.

Poli-USP – Engenharia elétrica com habilitação em computação / sistemas digitais
Em 2003 entrei na Poli. Em simultâneo, de 2003 a 2005 eu trabalhei como monitor/plantonista de exatas (matemática, física e química) no cursinho Anglo. Em 2006 eu iniciei a iniciação científica, meu primeiro instante como colaborador de um projeto open source (C++): escrevi um tutorial de como poderia ser inserido um algoritmo no projeto openModeller, além de um algoritmo simples baseado em distâncias (conforme sugestão do Renato De Giovanni, um dos desenvolvedores do projeto). O openModeller é um software para biólogos, feito para avaliar densidades de probabilidade de ocorrência de espécies em mapas, fornecidas informações sobre o ambiente e pontos de presença/ausência das espécies. Foi também durante essa graduação a primeira vez que compareci em um fisl.

Dentre os diversos projetos realizados durante essa graduação, acho que vale destacar os projetos das disciplinas de fundamentos da computação e de compiladores, além da pequena continuidade que fiz deles. Em uma máquina artificial (simulada) RISC de 14 instruções, um registrador de trabalho e 4KB de RAM denominada “MVN” (provavelmente uma sigla para “Máquina de Von Neumann”), o projeto da primeira disciplina foi a elaboração de um assembler para tal máquina em seu próprio assembly, a ser feito pela turma como um todo. Essa máquina tem como característica a ausência de instrução para endereçamento indireto, o que exige a modificação do próprio código na memória RAM em tempo de execução para realização desse tipo de operação, tornando o código, portanto, auto-modificável. Posteriormente, na disciplina de compiladores, o projeto foi um compilador de uma linguagem estruturada/imperativa para esse mesmo assembly, o qual escrevi em C++. A linguagem estruturada que adotei para a linguagem a ser compilada foi um “Pascal em português”, incluindo todos os laços e vetores do Pascal. Nesse caminho, por não gostar do burocrático simulador CLI em Java fornecido pela disciplina, fiz meu próprio simulador (em Delphi) da máquina, como uma GUI, e que permitia instruções de I/O para “entrar/sair do modo gráfico”, além de um único recurso gráfico: desenhar retângulos em um par de coordenadas fornecidas; o que possibilitou que eu fizesse uma nova versão do LuckBone, embora isso tenha exigido um pequeno otimizador (peephole) para o compilador.

Tetris_MVN

Tetris escrito para a MVN (aproximadamente 2.5KB)

LuckBone_MVN
LuckBone escrito para a MVN (aproximadamente 4KB)

Aparentemente o “gamification” de notas no meio acadêmico funcionou, ou eu talvez nunca tenha “desligado” a intenção de aprender tudo em simultâneo, como precisei para o vestibular. No mundo acadêmico, nunca fui reprovado, nem mesmo nos 3 vestibulares que fiz (Fuvest 2003, Fuvest 2008, Vunesp 2008), e até onde sei fui o único dessa habilitação a concluir o curso em 2007 com média acima de 8, com resultados ainda melhores nos cursos posteriores. Mas talvez paradoxalmente, foi nos dois laboratórios de engenharia de software que obtive minhas maiores notas durante essa graduação, apesar de eu ter sido nessa época muito crítico, talvez até hostil, com relação à normatividade, à burocracia e ao “senso comum” por vezes adotados junto à teoria e a prática relacionada à engenharia de software (não necessariamente nas disciplinas de engenharia de software). Absurdos como a incondicional santificação do uso de flags somado à demonização das quebras de laço como ocorreu em MAC2166 no primeiro semestre já haviam me sensibilizado bastante quanto a isso, muito mais que todo o passado que tive até então. Muitas leituras de textos clássicos fora das solicitações das disciplinas (e.g. “Structured Programming with go to Statements” de Donald Knuth) foram resultantes da aversão à impressão que eu tinha de que havia no curso uma imposição de valores, e valores bastante incompatíveis com os meus. É provável que houvesse um toque de exagero nessa impressão, o assunto tinha mais a ver com um trauma com relação a MAC2166 e minha opinião pouco favorável à ementa “cascata/waterfall + UML + RUP”, incluindo questões sociais e discursos específicos. Mas não devo esquecer dos colegas e professores que demonstravam concordar comigo, ao menos parcialmente, e o fato de que as discórdias aparentemente não tiveram relevância para a avaliação. Por exemplo teve professor me dando dicas de situações em que o famigerado “goto” fazia sentido sem ser nem quebra de laço, nem otimização e nem tratamento de exceção. No fundo, quem tem medo de usar um recurso dificilmente aprenderá quando faz sentido usá-lo. Outro exemplo foi o projeto do segundo laboratório de engenharia de software, um framework de estacionamento realizado pela turma inteira, com as partes se comunicando via SOAP. O Leandro Lameiro e eu ficamos com a GUI para visualização do estado do estacionamento (locais disponíveis/ocupados) e outras tarefas associadas a isso (basicamente um CRUD de vagas), na qual lembro de ter feito o “front-end” e ele o “back-end”. Devo muito a ele, assim como a outros da turma, pelo funcionamento desse projeto. Apesar de eu ter sido sempre bastante explícito ao dizer que considerava alguns diagramas como pouco ou nada importantes, a ênfase do laboratório ainda assim demonstrou ser prática, por exemplo lembro de ter recebido comentários positivos da professora por ter colocado um trecho de comentários no código com a descrição matemática do procedimento “detecção de click interno a uma vaga rotacionada” que precisei usar no projeto, tais comentários demonstraram ter mais valor do que diagramas meramente burocráticos.

Por vezes confesso ter sentido falta de que o curso fornecesse maior embasamento/aprofundamento teórico, por exemplo nas partes de teoria de probabilidades e de processamento [digital] de sinais, assuntos que precisei posteriormente para o mestrado e senti falta, embora eu tenha a impressão de que a recente mudança na estrutura curricular tenha melhorado isso, aproximando essa habilitação das demais dentro da engenharia elétrica e ganhando, por exemplo, uma disciplina extra apenas para teoria de probabilidades (victory!). Parte da teoria era obrigação do aluno ler em casa, e em muitos dos laboratórios (eletricidade, eletrônica, circuitos digitais, processadores, etc.) haviam ou “provinhas” antes do laboratório sobre a leitura proposta, ou até mesmo exigiam que o próprio aluno preparasse o modelo de relatório. Lembro que alguns da turma, eu inclusive, reclamávamos da carga de trabalho extra-aula exigida pelas disciplinas, mas a engenharia é e deve ser vista como enfaticamente prática(sem esquecer da bagagem teórica necessária). Afinal, quem precisa dormir?

Acho que é exagero descrever todos os detalhes do curso ou citar todos os projetos realizados durante essa graduação, e isso provavelmente seria cansativo, mas um último projeto que quero citar é um de meu último ano (2007) como aluno de graduação da Poli: meu TCC (trabalho de conclusão de curso), que foi um software editor/sequenciador de partituras/tablaturas com um pequeno suporte à entrada MIDI, e que era capaz de gerar arquivos MIDI com pulsação múltipla. Talvez eu re-escreva esse editor em Python no futuro, a partir de um refactoring do meu atual mini-projeto Guitar Tab Problem Maker e utilizando recursos prontos e otimizados ao invés de precisar implementar até mesmo o anti-aliasing gráfico e o componente para I/O MIDI. A conversão de partituras em tablaturas rendeu uma publicação no Workshop de Tecnologia Adaptativa graças ao uso de autômatos adaptativos (autômatos auto-modificáveis). Eu não conhecia Python até então, exceto de nome.

ECA-USP – Música com habilitação em composição musical

Durante as aulas de guitarra e outros tópicos acerca da música (percepção, teoria musical, contraponto, etc.) que tive com o Fernando Medeiros durante os anos de 2001 a 2004, ele falou sobre a existência de uma graduação em composição musical, curso que eu passei a ter grande interesse em fazer. Entrei em 2008 no bacharelado em música com habilitação em composição musical, o qual durou 5 anos, como a graduação anterior, embora o tempo ideal para composição fosse de 6 anos. Mas antes de entrar nessa graduação, estudei música em outras escolas, por exemplo o Studio Meyer e o Conservatório Beethoven durante os anos de 2006 e 2007, com diversos professores, voltados para canto e piano além de aulas sobre os diversos assuntos que dizem respeito à atividade musical tanto “tradicional” como “popular”, devido às necessidades que eu tinha tanto para a realização da prova de habilidades específicas em música do vestibular, como para as bandas nas quais eu tocava.

Das diversas atividades extra-curriculares realizadas durante essa graduação, vale destacar a participação junto ao grupo de improvisação livre e alguns mini-cursos que duraram alguns dias, como o de ChucK ministrado pelo Chris Chafe (CCRMA, Stanford) e o de PureData ministrado pelo Miller Puckette (CRCA, UCSD; autor do PureData). Tanto o ChucK como o PureData são linguagens de programação voltadas à síntese e ao processamento de áudio, incluindo interatividade e processamento em tempo real. Embora não tenha sido uma requisição, no terceiro dia do mini-curso de ChucK eu levei um pequeno improvisador de progressões harmônicas tonais escrito na linguagem, aquilo foi divertido.

O TCC da música foi dividido em duas partes, um trabalho acadêmico tradicional e uma apresentação musical com obras minhas. Para a apresentação musical, obtive a ajuda de 20 amigos que colaboraram na interpretação de minhas músicas, 18 dos quais participaram efetivamente como intérpretes de tais músicas em um extraordinário e inesquecível trabalho em equipe, os 2 demais foram responsáveis pelo equipamento eletrônico, além da gravação da Diskhursoopercute, obra minha para quarteto de cordas. A parte acadêmica foi um trabalho sobre H. J. Koellreutter que rendeu 169 páginas e que me levou a estudar alguns aspectos da cultura japonesa, além de educação musical, filosofia, política, entre outros assuntos. Esse trabalho incluiu como apêndice a transcrição fonética (legenda/subtitles) de dois vídeos. O Python se mostrou útil nas duas partes do TCC: na apresentação músical foi fundamental por conta de obras eletroacústicas em que utilizei Python (AudioLazy) para tarefas como segmentação e síntese de áudio (com posterior processamento, utilizando diversos softwares diferentes); para a transcrição fonética ajudou com um script que fiz para facilitar a cópia da legenda do formato Advanced Substation Alpha para uma tabela do LibreOffice, com o código de tal script presente como apêndice no TCC.

IME-USP – Mestrado em ciência da computação

Em simultâneo com a graduação em música, eu fiz o mestrado em ciência da computação, que lidou com processamento de áudio, motivado pelo problema da transcrição musical, que trata, a grosso modo, de construir uma “partitura” a partir do áudio. Resolver esse problema manualmente é uma capacidade necessária ao músico/musicista, principalmente aquele que pretende atuar com música popular, porém este pode consumir muito tempo, a depender do nível de detalhe da obra, da sua duração, da velocidade daquilo que é tocado, da simultaneidade de vozes, da existência de repetições, entre outros aspectos. A ausência da partitura de uma música é um problema que muitos enfrentam ao desejar tocar um “cover”. Na música popular, as partituras não costumam ser divulgadas, e o que existe disponível nem sempre é confiável, o que força tais artistas a serem habituados a realizar eles próprios uma “transcrição” musical, embora nem sempre façam isso por escrito.

O mestrado fez com que eu pesquisasse as áreas de filosofia da mente, ciência cognitiva, psicologia experimental e neurociência em busca de respostas para questionamentos bastante abstratos como “o que é/faz a audição?”, obviamente desejando respostas que fizessem sentido para uso prático, mas já seria de grande ajuda se minimamente pudessem me livrar dos arrogantes discursos que rejeitam “por princípio” (ou “como axioma”) a possibilidade de concretização de tais conversões por um computador. O que raios leva alguém a acreditar que há algo possível para humanos em geral mas “metafisicamente impossível por toda a eternidade” para outras máquinas físicas? É muito arbitrário…quem não acredita em “Strong AI” também não deveria ter motivos para acreditar em “strong natural intelligence”, o modelo ontológico adotado tanto faz na prática, é a segregação que necessita de uma justificativa. O “Computing machinery and intelligence” (1950) de Alan Turing é uma leitura fundamental a qualquer interessado em inteligência artificial e áreas afins. Passei a frequentar as reuniões do Cognitio, núcleo de apoio à pesquisa em ciência cognitiva na USP e posteriormente do Sem Neuras, ciclo de palestras de filosofia da mente na USP.

Foi nessa época que conheci linguagens como CSound, Faust, … e Python! Por conta das disciplinas que fiz na Poli (engenharia elétrica) em 2009 durante o mestrado (Reconhecimento de Padrões e Codificação de Voz, ambas enfaticamente práticas), passei a utilizar o GNU Octave como linguagem padrão para meus trabalhos que tinham a ver com computação, mas tal linguagem passou a ser gradativamente substituída por Python a partir do segundo semestre de 2011, por diversos motivos os quais detalho melhor no texto que segue. Graduação, trabalho, representação discente, computadores pessoais de baixa qualidade (trocas, preparo de ambiente, perda de dados e de hardware), a ausência de um laboratório para o grupo de computação musical do IME-USP e o fato de eu ter transitado entre linguagens (PureData -> Octave/MatLab -> Python) fizeram meu mestrado demorar mais que o comum, concluindo-o em 2013, porém com mais de 250 páginas e um importante legado: a AudioLazy, biblioteca/pacote DSP para o Python. Descrevo melhor o mestrado ao falar da história e das motivações da AudioLazy.

Como conheci o Python?

Apesar do Leandro Lameiro ter comentado comigo sobre o Python durante minha primeira graduação, apenas conheci o Python por conta de um coding dojo. Meu primeiro dojo foi de C++, ocorrido na Google em 2011 e organizado pelo Rodolpho Eckhardt, no qual estive presente para saber o que era um dojo, motivado pelo fato de que eu conhecia a linguagem. Gostei muito daquele dojo, particularmente por conta da questão social associada ao evento: desenvolvedores em um comportamento colaborativo e em um aprendizado coletivo, algo comum na área musical, mas em alguns aspectos inédito para mim na área de desenvolvimento de software, visto que não se tratava nem de uma obrigação acadêmica/corporativa e nem de militância, mas de pessoas que estavam ali porque gostavam de desenvolver software, queriam aprender ou queriam colaborar, construtivamente. Ok, eu tive a impressão de que alguns estiveram presentes apenas para “conhecer” a Google, nem tudo é perfeito. Os dojos seguintes que ocorreram na Google foram sobre Python, e foi então que eu decidi conhecer a linguagem. Esse comportamento colaborativo que descrevo também caracteriza a comunidade Python, cuja existência eu descobri posteriormente.

De julho de 2011 a fevereiro de 2014 eu passei a trabalhar para a Fuvest como prestador de serviços. Algumas das tarefas que me foram pedidas na Fuvest em 2011 e que tinham a ver com desenvolvimento de software, eu tentei fazer com Python, quando possível. Coisas gerais como envio de e-mails com templates (preenchimento automático), geração automática de planilhas (mesmo quando não me pediam para que a geração fosse automatizada), processamentos/verificações em bancos de dados, etc. eu fiz com Python, com aquilo que eu vi nos dojos, somado à rica documentação online disponível. Fiz também os 3 cursos online de Stanford no segundo semestre de 2011, e posso dizer que a disciplina de bancos de dados foi bastante útil no trabalho. Porém socialmente, por diversas razões, aquele ambiente foi, no início de 2012, crescentemente se tornando o mais desagradável de toda a minha vida. No final de 2012 eu migrei para trabalhar junto à reitoria da USP com estatística e desenvolvimento web, situação na qual desenvolvi o sistema do Programa Embaixadores da USP no ano de 2013, projeto em que utilizei diversas tecnologias como Nginx, Flask (Python), MongoDB, Celery e jQuery. Meu contrato foi prorrogado 11 (onze) vezes durante todo o período em que trabalhei na Fuvest, e posso dizer que utilizei Python em todos os anos nos quais trabalhei por lá. Em termos de open source, um dos softwares que desenvolvi nesse período foi um para a contabilidade da Fuvest, o brutoliquido, que foi inicialmente feito como uma GUI com PySide em 2012, e depois migrado para a versão web (Flask) disponível no meu GitHub. Outras contribuições incluem o back-end em MongoDB no simplekv (API do Flask-KVSession) e um exemplo na documentação do MongoDB onde era dito anteriormente não haver equivalente para o recurso SQL descrito, ambas contribuições motivadas pela necessidade prática do desenvolvimento do sistema do Programa Embaixadores.

Até o final de 2011, talvez por conta do que eu já havia feito no mestrado e por conta do curso de Machine Learning do Andrew Ng ter exigido o uso do GNU Octave, eu utilizava o Octave como calculadora até mesmo para as tarefas mais simplórias. No início de 2012, fiz a disciplina de eletrônica do MITx (hoje parte do edX), e tomei uma decisão um pouco radical: evitar o GNU Octave para fazer as contas necessárias utilizando somente o Python (com Numpy, quando necessário). Isso fez eu rapidamente me acostumar com o uso do Python para o meio científico, e com estruturas cada vez mais sofisticadas, e não muito depois passei a me sentir significativamente mais confortável no IPython do que no GNU Octave. Fazer os MOOCs da Udacity e Coursera também colaboraram com isso, inclusive em casos que podem parecer divergentes de início, como o curso de SaaS do Coursera, que me levou a conhecer geradores em Ruby, os quais para minha surpresa também existiam no Python. As necessidades dos projetos que eu tinha, conforme descrito neste texto de forma espalhada, me levaram a utilizar cada vez mais o Python em muitas das áreas em que eu atuava.

Humanidades e política

Enquanto eu cursava a Poli, eu erroneamente associei a ideia de “seguir normas/ordens sem pensar” à área de humanidades. A discussão sobre o que é melhor/pior para a legibilidade/compreensão humana, inclusive no contexto da engenharia de software, tem a ver com psicologia, mas sabemos que não é ela que admite respostas normativas incondicionais ou “sem lógica”. Pelo contrário, os assuntos de psicologia costumam me agradar bastante, era minha associação da área de humanas na época que estava nominalmente vinculada às imagens que eu tinha de comportamentos de determinada prática gerencial, política e jurídica, nas quais “obediência servil/incondicional ao ‘chefe’/administrador/gestor” e “ordem do juiz não se discute, se cumpre” eram vistos por mim como assuntos/responsabilidades “de humanidades”, já que esses são claramente assuntos que têm a ver com relações sociais humanas. Desde aquela época eu podia notar algum problema nessa associação da nomenclatura/referência, dado que eu queria fazer música e estava gostando daquilo que eu lia sobre filosofia, mas não estava clara a distinção entre o que fazia sentido e o que me incomodava, mas pelo menos sei que nunca foi uma área do conhecimento humano. Humanidades não tem lógica? Dificilmente algo poderia ser mais inadequado que dizer isso. Lógica é uma parte da filosofia, referente ao estudo da validade dos argumentos/pensamentos, caracteriza a filosofia analítica. Seguir normas/valores externos incondicionalmente/dogmaticamente é que não tem lógica.

Adentrei de diversas formas na área de humanidades, e hoje confesso, por vezes, sentir falta da área. Em 2007 a Wikipedia me motivou a ler de textos sobre a área de humanidades, por exemplo me levando a conhecer assuntos com os quais eu nunca havia tido contato. Foi como conheci a filosofia analítica e filósofos como Rudolf Carnap, autor da frase que utilizo já há algum tempo como assinatura em meus e-mails “It is not our business to set up prohibitions, but to arrive at conventions”, passagem de um trecho em que o autor fala sobre a amoralidade da lógica (Logical syntax of language, parte 1C17 “The Principle of Tolerance in Syntax”, 1937). Isso tudo me levou a ler os textos dos próprios autores (em PDF, às vezes traduzidos), e a participar de reuniões do grupo de filosofia analítica da FFLCH-USP. Não tive muito tempo para acompanhar tudo o que eles discutiram, e hoje provavelmente todos os que participavam daquele grupo já estão formados, mas em 2009 eu participei a frequentar o Cognitio e posteriormente (2011) o Sem Neuras, como já foi dito. Na continuidade eu entrei no grupo de estudo da racionalidade no Facebook, do qual participo até os dias de hoje. Não são sempre os mesmos temas mas isso tem me mantido próximo junto a discussões que normalmente me agradam bastante.

De 2009 ao primeiro semestre de 2011, fui RD (representante discente) em diversos conselhos da USP. Primeiramente fui RD do conselho do departamento de música, como titular, onde descobri o significado real do que é ser um representante (e como muitos “representantes” são tudo, menos representantes). Posteriormente entrei, como suplente, na CoC (conselho de coordenação de curso, se não me engano) também da música. Diante da greve da USP de 2009, tive evidências explícitas de pessoas mentindo descaradamente somente para chamar atenção das câmeras, colegas sendo violentados, entre outras atitudes que me pareciam tudo menos aceitáveis. Isso fez eu participar de um grupo chamado CDIE (Comissão para a Defesa dos Interesses Estudantis) que posteriormente formou a chapa Reconquista para o DCE. Por poucos votos, perdemos para a chapa “do PSOL”, mas isso foi suficiente para garantir cadeiras nos conselhos centrais da USP. Com isso, fui titular do CoG, conselho central da graduação na USP, do início de 2010 ao início de 2011, tendo o Alcyr Barbin Neto (direito) como suplente. Fui também RD em uma das câmaras anexas do CoG, a CCV (Câmara do Curriculum e Vestibular), e participei do grupo de trabalho que propôs as mudanças no vestibular Fuvest 2012. Talvez algum leitor me odeie por isso, mas fui eu quem defendi o aumento da nota de corte mínima do vestibular da Fuvest de 22 para 27 no momento em que essa ideia seria descartada, argumentando com um pouco de estatística a mudança do risco de se aprovar alguém que responde aleatoriamente a todas as questões, algo que resultou na aprovação da proposta pelo conselho. Para a argumentação precisei gerar uma imagem da distribuição binomial, fiz isso usando o GNU Octave naquela época, mas hoje eu teria feito com Scipy e Matplotlib, é algo bastante simples. Até hoje creio que os membros daquele conselho (daquela época) devem se lembrar de mim.

Como um decidido libriano, no início de 2011 eu participei do GEEA, grupo de estudos da escola austríaca de economia da FEA-USP. Não cheguei a postar nada no blog, mas participei das reuniões presenciais e discutia os assuntos na lista de e-mails. A proposta de Carl Menger foi excelente para me livrar daquela imagem do ourives e do papel-moeda como “origem do dinheiro” que eu havia visto no ensino fundamental [público] e que não fazia sentido algum fora do contexto “moeda lastreada” ou “moeda fiducionária”, como é o próprio caso do ouro (e do BitCoin). Mas por vezes o assunto discutido sempre me parecia algo que eu já havia visto em algum outro lugar. No “Ação Humana” de Mises há muitas passagens que remetem à filosofia da mente, por exemplo quando o autor diz que seguimos os desejos mas não desejamos o que desejar, tornando a noção de “livre arbítrio” irrelevante para a discussão que segue. “Utilidade” é um conceito que eu já tinha visto com o grupo de filosofia analítica (utilitarismo), em inteligência artificial na Poli (otimização multi-objetivo no planejamento de um agente) e até mesmo na aula magna que tive ao entrar na ECA, em 2008 (que por alguma razão lembro dela até hoje, por exemplo lembro que não utilizou nomes mas falou sobre utilidade marginal). Nessa época “econômica” assim como na época em que escrevi o TCC da música lembro de ter lido até partes de “O Capital” de Marx, assim como parte da obra de anarquistas como Rothbard, Proudhon e Bakunin, e posteriormente outros como B. Tucker e K. Carson.

Outros

Durante minha graduação na ECA, do fim de 2008 ao fim de 2009, eu participei da ECAtlética como “DM do xadrez” (diretor de modalidade), visitando outras cidades durante competições. A primeira vez foi o BIFE em Itapeva (SP), lembro de quando cheguei, eu estava completamente perdido, não fazia ideia do que seria, até o colchão inflável eu tive de comprar por lá, mas tudo foi bastante divertido. Posso ter detestado o odor de Piracicaba (SP) no Sampira, mas eu realmente gostei ter participado disso, do contrário estou certo de que teria me arrependido de não ter participado. Minhas viagens para outras cidades somente continuaram anos depois, a partir de 2013, não mais em eventos esportivos mas em eventos de software livre ou específicos de Python nos quais eu palestrei: fisl 14 (Porto Alegre RS), PythonBrasil[9] (Brasília DF), Latinoware 2013 (Foz do Iguaçu PR, e perdi R$10,00 no casino da Argentina), RuPy 2013 (São José dos Campos SP), Python Nordeste 2014 (Salvador BA), Python Vale 2014 (São José dos Campos SP); além de um iMasters’ Dev Day em Adamantina (SP) sobre dojos incluindo git, Ruby e Python, realizado junto com Leandro Facchinetti; e do Taubaté Perl Workshop (Taubaté SP), em que eu fui o “intruso” convidado para falar de Python (AudioLazy) em um evento de Perl, os Perl Mongers foram muito gentis! Dentre os eventos em que palestrei dentro da grande São Paulo, incluo o DevInSampa (2013), o Google Open Source Jam (2013), um Workshop de Python na Poli-USP com dojos simples em dois dias consecutivos (2013), o 7Masters Python de 2014, a Campus Party 2014 paulistana e o primeiro EITCCC (Encontro Internacional de Tecnologia, Comunicação e Ciência Cognitiva) realizado na UMESP, em São Bernardo do Campo. Eu coloco no Slideshare os meus slides das apresentações, cujas imagens de fundo foram feitas com a AudioLazy.

A partir de 2009, em todos os anos fui convidado pelo professor João Kogler para ajudar na disciplina PSI2222 “Práticas de eletricidade e eletrônica II” do segundo ano da engenharia elétrica da Poli como orientador de um projeto com um dos grupos de 4 alunos. Participei em 2009, em que eu propus um “Sequenciador Rítmico”, o qual foi feito com PIC com I/O MIDI; em 2012, em que os alunos propuseram o trabalho “Interruptor Musical”, o qual foi feito com Arduino; e com duas orientações em 2013, ambas utilizando a AudioLazy (Python), sendo um dos projetos uma pedaleira (com Arduino + PC), e o outro um softsynth para um teclado MIDI (com PyGame). Em 2013 expliquei o básico de git para os alunos e solicitei para que colocassem o trabalho deles no GitHub, vale a pena ver o repositório da pedaleira. Atualmente, pela IEEE, estou participando como mentor de um grupo de alunos na Poli que irão participar de maratonas de programação usando Python.

Há outros pontos (e.g. em algum instante eu também colaborei com o py.test, pyNES, Pingo, etc.) e muito que pode ser dito sobre cada assunto destacado aqui, mas acho que já escrevi demais, e acho que apresentei a maioria dos pontos sobre desenvolvimento de software que me pareciam ser relevantes como resposta. Mas para finalizar, um recado meu voltado aos aspirantes a desenvolvedores de software: não existem boas práticas / “atalhos”. Not, at all! Nem mesmo má práticas (ou todas são más, a vida é um inferno…mas isso seria romântico demais, prefiro algo mais contemporâneo). As práticas podem ser avaliadas como “boas” ou “más” para uma dada finalidade específica em um contexto prático específico, mas o resultado não é um “atributo” da prática, sendo necessário pelo menos a “tripla” que inclui a finalidade e o contexto. Vale a pena enfatizar o aprendizado, e principalmente maximizar a quantidade de técnicas/conhecimentos adquiridos, sejam “paradigmas”, “design patterns” ou o que for, visto que não me parece possível avaliar algo sem conhecê-lo ou sem ter com o que comparar. Saber o que fazer, como fazer e como usar cada técnica/tecnologia é mais importante do que saber onde colocar adjetivos. Mas vale acrescentar que esse assunto remete a problemas antigos na filosofia, como o “is-ought problem”, dito por D. Hume há alguns séculos acerca da dificuldade de obter sentenças prescritivas a partir de sentenças descritivas; quem realmente achar que existe boa/má prática, estarei muito curioso em saber como o problema centenário foi solucionado.

And now for something completely diff…

Se você diz educadamente a um humano “acende a luz”, supondo que ele realizará o “comando” solicitado, ele caminhará até algum interruptor e o pressionará, talvez pressionando vários interruptores enquanto a luz não acende, ou mesmo trocando a lâmpada quando notar que esta estava queimada, fazendo algo depois de ter ligado o circuito com a lâmpada, talvez voltando para onde ele estava ou entregando a conta a ser paga pelo serviço, e se não pagar, a lâmpada exibirá uma propaganda nas paredes e teto alternando de tempos em tempos a posição e o produto anunciado. Pelo menos enquanto não houver uma linguagem com similar poder de expressividade para desses 3 “tokens” (extraídos do áudio) possibilitar uma ação similar, pode apostar que as linguagens continuarão mudando bastante. Mas confesso que estou torcendo para o robô dizer “acende você, folgado!”…

O que faz a Audiolazy, qual foi a motivação e os motivos para desenvolvê-la?

https://github.com/danilobellini/audiolazy

A AudioLazy é uma biblioteca (ou um pacote) de DSP (Digital Signal Processing) para o Python. Resumidamente, ela trata de realizar processamento, análise e síntese de sinais unidimensionais no tempo. Há, como o nome já sugere, um destaque aos sinais de áudio, dado seu vínculo com o PyAudio (PortAudio) para realizar entrada/saída de áudio, mas não existe nada que impeça o uso do pacote para outras aplicações. A título de exemplo, a AudioLazy já foi utilizada para geração de imagens (todos os fundos de slides das minhas apresentações dos últimos anos foram criados com a AudioLazy) e criação de sequências utilizadas em cálculo numérico. A grosso modo, a AudioLazy pode ser vista como um complemento aos geradores e aos itertools do Python para lidar com operadores elemento-a-elemento e com estruturas voltadas para processamento de sinais. Mas análise, síntese e processamento são termos muito vagos, e talvez uma especificação dos recursos pareça uma “sopa de letrinhas” para alguém leigo no assunto. Especifico abaixo alguns tópicos, além de seus vínculos com processamento de sinais e, em particular, com a AudioLazy:

* Real-Time + Expressive
A ênfase do desenvolvimento sempre esteve na expressividade de código, no sentido de permitir que abstrações “de alto nível” fossem fáceis de expressar sem perder o controle sobre o “baixo nível”. Em outras palavras, tratar sinais e filtros como objetos sem deixar de lado o controle direto sobre as amostras de áudio (algo similar à ideia de “pixel”, mas para o som). Isso significa que eu queria uma API que evitasse preocupações com detalhes como índices, “condições de contorno/finalização” ou “ordem de parâmetros” a menos que óbvios ou estritamente necessários. Outro aspecto enfatizado foi a possibilidade de funcionamento em tempo real, o que também influenciou a organização do pacote como um todo. Isso foi possibilitado pela adoção de um sistema de avaliação tardia (deferred) para os sinais evitando refazer cálculos quando estes são usados mais de uma vez, algo que leva o nome de avaliação “lazy” (ou “preguiçosa”), de onde o nome “AudioLazy” foi derivado. Além disso tudo, o desenvolvimento buscava manter a máxima integração com o que já existia no Python, por exemplo ao interpretar qualquer iterável do Python contendo números entre -1.0 e 1.0 (ponto flutuante) como um sinal.

* Motivos / motivações
As motivações incluem tanto as necessidades do mestrado como aquilo que eu, como musicista, tinha como intenções práticas. No mestrado eu precisava de modelos psicoacústicos, modelos baseados no processamento direto nas amostras do áudio, e modelos baseados em blocos, todos convivendo simultaneamente para analisar áudio, incluindo modelos psicoacústicos. Minha necessidade prática era também a de um músico que sempre queria poder ouvir o que estava fazendo com aquele monte de números, se possível antes de todo o processamento ser realizado, e se possível enquanto eu estivesse falando/tocando, além de obviamente a vontade de adquirir maior liberdade para manipular o som, seja em termos de processamento ou de síntese. Havia também a intenção de utilizar o pacote em jogos, como ocorreu com o Musical Mines, por exemplo. Após a finalização do mestrado, por dias fiquei horas “brincando” com a AudioLazy procurando novos timbres com variações de parâmetros em efeitos simples e famosos como distorções, delay e flanger. Mas o projeto até o início de 2013 caminhou junto ao desespero em que eu teria de terminar em um semestre o mestrado, e para isso eu precisava enfatizar a análise acima de tudo, porém o fato de que eu sempre enfatizei o processamento em amostras ao invés do processamento em blocos fez com que a divisão análise-processamento-síntese não estivesse tão clara na época, parte dos recursos de processamento foram feitos como etapas de análise (e.g. filtros lineares para implementar o gammatone), assim como parte dos recursos de síntese para análise controlada, comparação de uma ressíntese com o áudio original e reprodutibilidade do trabalho realizado.

* Breve histórico
De início, busquei os recursos que queria em diversas outras linguagens. Cheguei a utilizar PureData, ChucK, CSound e GNU Octave (MatLab) durante a maior parte do meu mestrado, até finalmente projetar um banco de filtros o qual supostamente serviria para coletar a harmonia da música. Diversos experimentos de áudio haviam sido realizados nessas linguagens, incluindo modelos de identificação de ritmo, mas também houve modelos que eu simplesmente não achei uma forma simples de ser implementado nessas linguagens. Em junho de 2012 eu teria de apresentar no IME-USP sobre o capítulo de processamento espectral do DAFx, evento para o qual me preocupei em utilizar o Python onde consegui. Nasceu no dia 27 de maio meus primeiros experimentos com Python para processamento de áudio, motivados pelo agendamento dessa apresentação. Naquele instante, utilizando o Numpy e Matplotlib, criei implementações alternativas da DFT, uma STFT bastante diferente da atual da AudioLazy e um espectrograma, os quais precisava para a apresentação. Isso não foi suficiente, eu precisei utilizar o código do próprio livro, que estava escrito para o MatLab mas funcionou com o GNU Octave. Minha ideia seguinte era a de que eu poderia tentar implementar os códigos do livro em Python e melhorar a implementação para que esta evitasse tortuosidades, isto é, a intenção era uma expressividade de código. Após a apresentação, e já em julho de 2012, iniciei em TDD experimentos que levaram ao surgimento de uma classe: Stream, a qual visava ser um “gerador com operadores do Numpy”, algo bastante similar ao que existe atualmente. Na época havia um monkeypatch de métodos de operadores, e eu continuei com a ideia, criando 2 recursos inexistentes na AudioLazy. Um desses recursos era a classe Function, que lidava com funções com operadores, literalmente permitindo escrever “_ + 2*_” no lugar de “lambda a, b: a + 2*b”. É inegável que eu tinha interesse em fugir do paradigma imperativo. O outro recurso foi a classe LTITime, que criava filtros LTI descritos pelo seu equacionamento no tempo como “y[n] = x[n] – x[n-1]“. Isto tudo funcionou com os objetos x, y, n e _ (que eu chamava de “wire” por conta do Faust), bastando criar um “y” para cada novo filtro a ser criado. Entretanto, os lambdas alternativos posteriormente me pareceram desnecessários naquela época e os filtros no tempo tinham a dificuldade de necessitar de 3 objetos, sendo intratáveis em casos como “y[n] – y[n-1] = x[n]” (expressão à esquerda da atribuição) e “y[n] = y[n-1] * x[n]” (não-linear). Entretanto, o LTITime me levou à criação da classe LTIFreq e do objeto z, os quais estão presentes na AudioLazy (atual classe ZFilter), e permitia implementar os filtros através do equacionamento no domínio Z, “filt = 1 – z ** -1″ passaria a ser o “y[n] = x[n] – x[n-1]“. Pode-se dizer que isso foi o período embrionário da AudioLazy, surgindo a partir desses arquivos pouco ou nada vinculados entre si. Os polinômios surgiram posteriormente como uma refatoração da LTIFreq. Conheci o py.test e migrei todos os testes do unittest para o py.test. Após diferentes tentativas de monkeypatch, decorators e class factory para a sobrecarga massiva de operadores que ocorria com o objeto z e com os sinais, descobri como esse processo poderia ser feito com metaclasses com reaproveitamento de código para as diversas classes que precisavam desse recurso, nascendo então uma das classes do “core” da AudioLazy: AbstractOperatorOverloaderMeta. Em outubro, a AudioLazy 0.01 nasceu, e pouco tempo depois lancei a versão 0.02, já com alguns recursos para síntese em tempo real como a classe ControlStream e o exemplo mcfm.py, o primeiro dos exemplos da AudioLazy. O restante da história está no GitHub, mas vale dizer que a versão 0.04 foi a utilizada para a defesa do mestrado, com a qual fiz o modelo modificado do banco de filtros outrora escrito para o GNU Octave. A versão 0.05 foi finalizada para o RuPy de 2013 e a próxima versão, 0.6, está para ser lançada em breve.

* Análise
Análise de áudio ocorre, por exemplo, em um afinador de guitarra, que diz qual é a nota sendo tocada, e esse exemplo está disponível com a AudioLazy. Explicitar o instrumento, os acordes e o ritmo de uma música apenas com sua gravação é um complicado procedimento de análise. Há outras possibilidades que não têm a ver com música, como a identificação de fonemas, locutores (speaker), localização do emissor, etc.. A AudioLazy possui diversos recursos que podem auxiliar nessas tarefas, como a taxa de cruzamentos no zero, a predição linear (LPC), a coleta de envoltórias, entre outros. Minha intenção inicial com a AudioLazy foi possibilitar que complicados modelos de processamento de sinais pudessem ser descritos de maneira simples. Em meu mestrado, eu tinha um grande desafio: criar um algoritmo de análise de áudio que permitisse transcrever músicas, algo que pode ser compreendido como “escrever a partitura de uma música a partir de sua gravação” ou mesmo “converter MP3 em MIDI”. O mestrado resultou em diversas experimentações incluindo tarefas simples de transcrição como a identificação de ritmo de eventos sem “ataque” definido, de altura (afinador de guitarra) e ritmo harmônico, sendo a AudioLazy, em minha opinião, a principal contribuição social resultante.

* Síntese
Síntese de áudio é algo mais comum de ser visto. Quem nunca viu um teclado sintetizador? A síntese por modulação (AM, FM, anel) é trivial na AudioLazy, e muitos sintetizadores famosos (e.g. Yamaha DX7) lidam com esse tipo de síntese. A síntese aditiva, ou “soma de senoides”, também é possível, e com o sistema de consulta à tabela não é difícil personalizar diferentes formas de onda, inclusive formas de onda variantes no tempo. Com gravações e ruído branco é possível realizar síntese subtrativa através do processamento do sinal, com filtros/efeitos. Por exemplo o modelo de Karplus-Strong “digitar” (digital + guitar) é um modelo de síntese subtrativa está implementado em uma linha de código na AudioLazy. Ainda sobre a síntese subtrativa, a AudioLazy inclui um exemplo com síntese de formantes para que o computador pronuncie vogais em cima de uma onda dente-de-serra. Há outros recursos básicos como envoltórias ADSR e exemplos dos diferentes tipos de síntese.

* Processamento
Há muito que poderia ser dito sobre processamento. Fundamental na área de processamento de sinais são os filtros lineares, e a AudioLazy inclui filtros lineares variantes e invariantes no tempo através da própria equação da transformada Z (e.g. “1 – z ** -1″). Alguns dos filtros mais comuns já estão implementados com diversas estratégias diferentes, as quais fazem parte da AudioLazy. Por exemplo, o passa-baixas de um polo variante no tempo serve como modelo digital do potenciômetro e capacitor presentes em muitas guitarras como um knob que fica ao lado do knob de volume, associado à “qualidade” timbrística de uma guitarra. Mas eu queria e precisava de um sistema completo que possibilitasse análise, síntese e processamento de áudio, de maneira simples e que não criasse travas artificiais como a de impossibilitar o acesso às amostras para tarefas não necessariamente lineares. Além de filtros passa-baixas, passa-altas, ressonadores e comb, todos possivelmente variantes no tempo, é também possível realizar processamento não-linear, desde algo simples “memoryless” como uma distorção com “clip” ou com arco-tangente a processamento não-linear variante no tempo através de funções geradoras do Python, as quais podem literalmente fazer qualquer coisa com as amostras de áudio. Como inserção mais recente de recurso à AudioLazy para a futura versão 0.6 (a ser lançada em breve), esta incluirá a simples realização dos 9 passos de processamento via STFT (Short Time Fourier Transform) usando por padrão a FFT do Numpy, o que permite a simples criação de efeitos de phase vocoder como robotização de voz ou time stretch (modificação da duração do áudio sem mudar a altura/frequência).

* Psicoacústica / ciência cognitiva
Para transcrever, minha intenção durante o mestrado era a de qualificar o resultado de uma análise através de uma ressíntese da solução proposta, ou de algo equivalente na forma de um feedback que avaliasse a qualidade da análise realizada. Passei muito tempo transcrevendo músicas manualmente, e minha intenção era levar a experiência do processo manual para o processo automatizado, mas para isso eu precisaria que o computador tivesse uma audição similar à de um humano. Isso teve como consequência a busca por modelos para a audição humana, alguns dos quais implementados na AudioLazy. Em particular, faz parte da AudioLazy o modelo de Patterson-Holdsworth com os filtros gammatone e modelos de ERB, que servem como um modelo linear para a filtragem realizada pelo sistema auditivo, ou como diriam os próprios autores em 1988, “[...] to describe the shape of the impulse response function of the auditory system as estimated by the reverse correlation function of neural firing times”. Atualmente a AudioLazy também conta com o modelo de intensidades, as curvas do ISO/FDIS 226:2003 para conversão de intensidades em *phon* (psicoacústica) para *dB SPL* (física).

Captura de tela de 2014-10-16 18:56:53 Captura de tela de 2014-10-16 18:56:59
“Uma narrativa de ficção” do mestrado em quadrinhos, ilustração da objetividade na transcrição.

* Outros recursos
Há uma integração com o Matplotlib para avaliação de filtros LTI (lineares e invariantes no tempo), o que pode auxiliar no projeto de filtros, mas assim como as demais integrações (PyAudio, Numpy), não se trata de uma dependência, visto que estes não estão disponíveis para o PyPy mas a AudioLazy pode ser utilizada em tal implementação do Python. Algumas coisas úteis para pensar musicalmente são os conversores entre valores de frequência (em hertz), nomes de notas em strings (e.g. “A4″ para o lá central) e valor MIDI (em semitons), que facilitam o uso de notações musicais em meio ao código. Os polinômios usando o “x” e a interpolação por polinômios de Waring-Lagrange também podem ser úteis em tarefas envolvendo cálculo numérico. Mas creio que seja desnecessário listar todos os recursos disponíveis, essa informação consta no repositório da AudioLazy.

* Compatibilidade e integração
O código dessa biblioteca é único para ambos o PyPy, o CPython 2.7 e o CPython 3.2+ em múltiplas plataformas. A metaprogramação é fundamental ao núcleo do pacote, dados recursos como a sobrecarga massiva de operadores (através de, literalmente, uma “metaclasse abstrata”) e o JIT (Just In Time) que cria em tempo de execução as funções dos filtros lineares. O resultado é um pacote multiplataforma escrito em puro Python que possibilita processamento de áudio em tempo real. Além da expressividade em buscar a integração com os tipos básicos e interfaces do próprio Python, há exemplos e testes da AudioLazy em conjunto com muitos pacotes como o Scipy, o Sympy ou o music21.

E para quem frequenta coding dojo, foi criado o projeto dose, um sinalizador de testes em tempo real, como ele funciona?

https://github.com/danilobellini/dose

30956_4431661905977_1681362632_n

O dose teve origem com uma tentativa de realizar nuances gráficas em janelas do wxPython, tendo seu desenvolvimento iniciado no dia 26 de julho de 2012. Eu fiquei um tempo considerável “brincando” com os recursos do wx para possibilitar uma estética simples, mas que me agradasse. Por exemplo, o tamanho e orientação precisavam ser ajustáveis, mas eu queria que fosse sem as bordas convencionais de janelas e arredondadas nos cantos, semi-transparente, movido com o click em qualquer lugar da janela mas com tamanho modificado quando o Ctrl fosse mantido pressionado e com a transparência modificada quando o Shift forsse mantido pressionado. Pura estética e interação no início, um “front-end” sem nada sendo realizado internamente no “back-end”.

Mas por que fazer uma janela com tais formato e conteúdo? Desde o início, a intenção era a de criar um semáforo/sinalizador/farol para auxiliar no TDD (Test-Driven Development), em particular para ser utilizado em dojos, informando o estado atual do código: verde representando “testes passando” e vermelho representando “algo quebrou nos testes”. O amarelo foi utilizado como um intermediário para indicar “testes em execução”. O nome, dose, vem de “DOjo + SEmáforo”, cujas sílabas iniciais são as mesmas em português e em inglês. Há quem diga, talvez com muito esforço, que a similaridade com o nome “nose”, um pacote de testes para o Python, vincule o nome “dose” à ideia de testes, ou talvez isso já seja um exagero.

Posterior ao desenvolvimento de toda a interface, busquei informações de como o “tdaemon” funcionava. Esse era o software que utilizávamos em dojos para executar a suíte de testes quando algum arquivo era modificado. Lendo seu código, pude notar que era realizado um polling, sistematicamente verificando a data de modificação do arquivo, o que não era o que eu gostaria que o dose fizesse. Buscando formas alternativas que utilizassem o inotify ou, preferencialmente, fossem multiplataforma sem precisar de polling a menos que estritamente necessário, encontrei o pacote “watchdog” para o Python, dependência do dose para realizar o monitoramento dos arquivos. A ação de chamada dos testes ocorre no evento de mudança em arquivos que estejam em no diretório sendo monitorado (aquele em que o dose é chamado), junto a seus subdiretórios, com algumas restrições configuráveis. Isso significa que os testes são chamados toda vez que algum arquivo é modificado, sem consultas periódicas desnecessárias ao instante de modificação do arquivo. Em setembro de 2012 eu retomei o desenvolvimento do dose.py para unificar o watchdog com a interface gráfica que eu outrora havia criado.

O comando para chamada dos testes é um parâmetro importante para o dose. Antes da existência do dose, por vezes utilizávamos o watch do Linux para rodar periodicamente o comando que realizava os testes, e por conta da maneira como o watch do Linux era utilizado, o dose foi modificado para permitir receber como parâmetros o comando que realiza os testes, por exemplo chamando “dose py.test” no diretório do projeto. Chamar o dose dessa forma o inicia, já rodando o py.test inicialmente e usando o console em que o dose foi aberto para emissão das mensagens resultantes dessas chamadas do comando de chamada dos testes.

Qualquer comando pode ser utilizado, inclusive comandos com parâmetros e para o shell. Chamar o dose com “dose py.test -k arq” irá rodar com o comando “py.test -k arq”; chamar com “dose ‘py.test -vv -k arq | grep arq'” irá rodar o comando que segue. Claramente, qualquer comando pode ser utilizado, mesmo que nada tenha a ver com o Python, o que importa é que este finalize com um valor de retorno 0 caso os testes tenham passado, ou qualquer outro valor, caso contrário. Essa é a informação utilizada pelo dose para selecionar a cor a ser exibida visualmente. Pela liberdade de escolha do comando, o dose é um semáforo agnóstico de linguagem e de framework de testes, e já foi utilizado em dojos de diversas linguagens como Python, shell script e C.

Também temos o fractals, o que ele faz é renderizar fractais. O que é o fractals e e quais as vantagens em utilizá-lo?

https://github.com/danilobellini/fractals

Fractais são construções “recursivas”, isto é, suas partes são réplicas de si próprias. O “fractals” é uma implementação em Python que gera imagens de fractais referentes ao conjunto de Julia para o mapa quadrático com uma constante fornecida como parâmetro, além do famoso fractal de Mandelbrot. Esse micro-projeto foi criado como uma curiosidade após uma conversa sobre imagens de fractais, além da simplicidade para a obtenção de um resultado satisfatório.

O que acontece se repetirmos a mesma operação diversas vezes, gerando uma sequência de valores? Isso depende da operação, mas já conhecemos sequências que podem ser definidas dessa forma, como as progressões aritmética e geométrica: o novo valor é sempre o imediatamente anterior aplicado uma função que no caso é uma soma ou um produto por uma constante. Também sabemos que a progressão geométrica tem um comportamento diferente dependendo da razão utilizada, podendo permanecer constante (razão 1), ser periódica (e.g. razão igual à unidade complexa), crescer ilimitadamente em módulo com alternância de sinal (e.g. razão -2), convergir para um valor específico, entre outros. Esses exemplos incluem comportamentos estacionário, periódico e explosivo para a dinâmica de um sistema. A razão pode ser qualquer número complexo, mas podemos dividir aqui o conjunto dos complexos em duas partes: o conjunto de Fatou e o conjunto de Julia. A grosso modo, o conjunto de Fatou é a união dos abertos caracterizados pelo comportamento “regular” em sua vizinhança, e o conjunto de Julia é seu complemento, caracterizado pela grande variação de comportamento para valores próximos, ou “caótico”. O que vemos nos fractais é o próprio plano complexo, em que cada pixel indica quantas iterações foram necessárias até a sequência ultrapassar, em módulo, um limiar (Escape Time Algorithm), uma forma de estimar uma “distância” da posição central do pixel até o conjunto de Julia. No fractal de Julia, o valor da constante “c” é fixa e o valor inicial é a coordenada complexa do pixel sendo avaliado, no fractal de Mandelbrot o valor inicial é zero e a constante “c” é a coordenada complexa do pixel sendo avaliado. No caso dos fractais gerados pelo software citado, ao invés de aplicar iterativamente a função “f(z) = z * a” relativa à progressão geométrica, é utilizada a função “f(z) = z^2 + c”.

Muita matemática! O objetivo do fractals era criar um maneira simples de gerar as imagens de fractais para diferentes parâmetros, o que ocorre de imediato chamando o software via linha de comando com os parâmetros desejados. É difícil falar em vantagens de utilizá-lo sem uma base de comparação, talvez seja mais relevante dizer que fractais são úteis para o estudo do comportamento de sistemas dinâmicos complexos, para processamento e compressão de imagem e áudio, geração de paisagens artificiais, composição musical, etc., mas obviamente sem esquecer da apreciação estética.

http://www.numberphile.com/videos/minussevenfour.html
Prime Divisors and the Mandelbrot Set

E o Pyturing, uma máquina de Turing feita em Python em uma competição no Garoa Hacker Clube, como foi a experiência de fazer em pouco tempo?

https://github.com/danilobellini/pyturing

Não foi a primeira vez em que tive de fazer um trabalho às pressas, mas devo dizer que essa vez teve aspectos diferentes. A ideia de fazer uma máquina de Turing em Python surgiu ao ler discussões da lista do Garoa, quando alguém falou sobre estudar a máquina de Turing e eu pensei: por que não um dojo de máquina de Turing? E a resposta era óbvia: uma linguagem e um simulador para a máquina de Turing seriam necessários para esse fim. A competição GCC2014 (Garoa Code Competition) exigia que fosse uma aplicação web usando Python, com Flask ou Django, ou então Ruby, com Sinatra ou Rails. Alguns de meus últimos trabalhos na Fuvest e reitoria da USP foram realizados utilizando o Flask, o qual seria minha escolha óbvia para uma “maratona”. Com o tempo disponível, mesmo que a máquina de Turing não fosse o projeto a ser realizado, eu já estaria inclinado a algo mais próximo de um single-page com atualizações via AJAX ou minimamente um back-end e front-end mínimos para que o AJAX fosse deixado para o futuro mas com as saídas em JSON prontas, como ocorreu. Além de evitar tarefas demoradas como a criação de um CMS, eu literalmente pretendia fugir de preocupações com configuração de ambientes e outras atividades “de sysadmin” durante a maratona: quem vai para uma maratona precisa ter preparado a priori o ambiente para possibilitar testes/deploy facilmente, sempre.

Combinei com o Nicolas França que faríamos juntos o Pyturing. Ele queria aprender sobre front-end, e ficou combinado que ele fizesse o HTML e CSS do Pyturing, enquanto eu faria o parser e simulador da máquina. Durante as 11 primeiras horas, eu fiquei lendo e relendo o artigo do Turing, preparei a linguagem em EBNF e iniciei sua implementação. Uma falha, dado que o projeto da linguagem poderia ter sido realizado anteriormente. Primeiramente pensei em deixar a simulação no front-end via JavaScript e até mesmo escrevi algumas linhas de código em CoffeeScript, mas depois abandonei a ideia por achar que seria mais simples, tanto para mim como para o Nicolas, se eu deixasse essa parte no back-end em Python, com a vantagem de que futuramente o código resultante poderia ser utilizado como uma API de máquina de Turing em outros projetos. Todo o Pyturing ficou pronto nas 13 horas restantes, seguindo TDD com o py.test para o módulo da máquina de Turing. O Nicolas fez o front-end usando o Bootstrap, e, durante as últimas horas da maratona, eu expliquei algumas coisas de CSS e de como o navegador poderia ajudar para que ele mesmo fizesse o alinhamento dos elementos, o que também colaborou em minimizar a dependência do projeto com relação ao Bootstrap, que ficou restrita à estética dos botões. Nos últimos minutos precisei fazer apenas os ajustes para que uma versão mínima funcional estivesse finalizada a tempo, o que consegui, embora parcialmente. Tal versão, que não continha todos os recursos atuais, teve seu commit realizado literalmente no último minuto disponível.

O resultado do GCC2014 foi uma API de máquina de Turing com uma singela aplicação web que possibilitasse o uso da API criada. Poucas mudanças foram realizadas posteriormente na interface web, por exemplo o Bootstrap deixou de ser utilizado, embora existam várias propostas de continuação em aberto. Com mais tempo disponível, a API foi complementada, uma interface CLI foi inserida ao projeto, e o Pyturing agora está no PyPI e Travis, como uma aplicação Web + API + interface CLI para máquina de Turing.

Há também um jogo bem bacana derivado da Audiolazy que é o Musical Mines, um jogo de campo minado personalizado, como foi que ele foi desenvolvido?

https://github.com/danilobellini/mmines

Eu gostava do joguinho de campo minado, e várias das tentativas que tive de experimentar jogos educativos voltados ao estudo da percepção musical foram frustradas, ou o “jogo” era chato, ou não ficava claro onde eu acertei/errei, ou o mesmo induzia vícios por repetições que levavam à utilização indevida de contexto. Pretendo no futuro implementar outras das diversas ideias que já tive para jogos voltados para a educação musical, mas no momento o único jogo finalizado que tenho é o Musical Mines.

screenshot
Musical Mines

O objetivo o jogo é o mesmo do campo minado tradicional: identificar todas as posições sem uma mina/bomba que possa explodir. Porém, ao invés de fornecer por escrito o número de células vizinhas explosivos ao clicar em uma posição, o número é fornecido através de um intervalo em semitons. Isso evidentemente cria um vício para intervalos curtos como de semitom e tom, mas auxilia no aprendizado de tais intervalos. Ao clicar em uma posição, o fundo verde indica que ela está selecionada, e você pode digitar um número para ser colocado como o intervalo daquela posição, embora a avaliação se o valor estava correto ou incorreto somente ocorre ao final do jogo (ou, para os cheaters, caso o jogo seja configurado pra sempre exibir os números). O objetivo era criar um jogo de campo minado para ajudar na educação musical, em particular na percepção de intervalos fora de um contexto tonal.

Embora tenha sido recriado posteriormente, ele surgiu primeiramente em C++ com gtkmm/cairomm no primeiro semestre de 2010, como uma tentativa de fazer uma GUI usando gráficos vetoriais similar à abordagem da coletânea de jogos de lógica do Simon Tatham. Apenas posteriormente inseri a lógica do jogo, a qual desde o início enfatizaria a música (diferente do Simon Tatham, que enfatiza puzzles totalmente dedutivos). Eu não cheguei a finalizá-lo naquela época, gastando muito tempo quando precisei de um pacote para síntese e reprodução de áudio em C++. Para pelo menos testar o que eu havia feito, segui a sugestão que me deram de usar o GNU Octave + sox mas o atraso resultante era inaceitável e aquela gambiarra também não era digna de orgulho. Recomendaram que eu tentasse uma integração com o PureData, mas o que eu queria sempre foi algo mais simples, visto que eu mesmo poderia sintetizar/processar o áudio para somente jogar a forma de onda resultante em uma saída de áudio. Em outras palavras, o que eu precisava mesmo era apenas saída de áudio multiplataforma (e.g. PortAudio), o restante eu poderia fazer “na unha”. Posteriormente eu descobri o STK (The Synthesis Toolkit in C++), mas eu acabei abandonando o jogo por outra razão: o uso do gtkmm/cairomm deixou o jogo gigantesco para quem quisesse rodá-lo no Windows.

O Musical Mines também foi um incentivo ao desenvolvimento da parte de síntese da AudioLazy, recursos como o TableLookup e adsr (síntese aditiva) foram de início criados especificamente para esse jogo. Comecei a migrar meu código do C++ com gtkmm/cairomm para o Python com wxPython em 14 de julho de 2012, e creio que a síntese de áudio tenha sido a parte mais simples do código do jogo desde o início de seu desenvolvimento, já que praticamente todas as internalidades dessa parte ficaram com a AudioLazy.


por Eric Hideki em 16 de October de 2014 às 22:11

October 15, 2014

Magnun Leno

Hack ‘n’ Cast v0.6 - Python

Python é uma das linguagens que mais cresceram nos últimos anos. Boa parte se deve ao fato de sua simplicidade, sintaxe intuitiva e de fácil aprendizagem, mas não podemos negligenciar a grande força motriz desta linguagem, sua comunidade.

Baixe o episódio e leia o shownotes

por Magnun em 15 de October de 2014 às 06:00

October 14, 2014

Álvaro Jüsten

Hackathon do SESI Cultura Digital 2014

As hackathons ("maratonas hacker"), também conhecidas como hack days, hack fests ou code fests são maratonas que envolvem desenvolvimento de algum software, em geral sobre um tema específico e com alguma premiação ao final. Em geral os grupos participantes possuem desenvolvedores de software, designers e administradores, remetendo à equipe de uma pequena empresa. Muitas hackathons visam resolver algum problema ou mesmo fomentar a criação de empresas startups na área-tema.

Desde que conheci o conceito gostei bastante, afinal é uma forma de incentivo a desenvolvimento de aplicativos inovadores, em geral com algum cunho social. Mesmo os grupos que não são premiados desenvolvem algum aplicativo, que pode ser útil ou até mesmo se tornar um negócio no futuro. Tenho visto várias hackathons relacionadas a dados abertos, que é um tema super interessante e, na minha visão, pode mudar a forma sobre como vivemos em sociedade.

Brasil.IO: Dados abertos para um Brasil mais ligado
Brasil.IO: meu projeto pessoal de dados abertos

Recentemente fui convidado pela organização do SESI Cultura Digital a ser tutor da Hackathon SESI Cultura Digital 2014, uma maratona com prêmios de R$ 20.000, R$ 10.000 e R$ 5.000 para os melhores projetos, podendo ser feitos por grupos de 3 a 5 pessoas. O objetivo dessa hackathon é fomentar o desenvolvimento de soluções ambientais para o estado do Rio de Janeiro, nos seguintes eixos temáticos:

Festival SESI de Cultura Digital 2014

Se você tem interesse, se inscreve logo pois as inscrições vão somente até dia 18 de outubro! Cada grupo participante receberá um Kit Arduino! o/

A minha tutoria será na área de fontes de dados relacionadas a monitoramento do ar e qualidade da água. Além da hackathon, o evento contará com várias outras atrações, como palestras e oficinas (também serei tutor de duas oficias de Arduino, que já estão lotadas!).

Os grupos terão dois dias (23 e 24 de outubro) para desenvolver um protótipo e terão de apresentá-los a uma banca avaliadora no dia 25. Durante os dias 23 e 24 serão feitas diversas apresentações para facilitar o trabalho dos grupos, bem como várias tutores estarão disponíveis para tirar dúvidas e colaborar no desenvolvimento dos protótipos.

Que tal participar? Curtiu a ideia? Compartilhe com seus amigos! :-)

por noreply@blogger.com (Álvaro Justen "Turicas") em 14 de October de 2014 às 23:57

October 13, 2014

Gustavo Niemeyer

mgo r2014.10.12

A new release of the mgo MongoDB driver for Go is out, packed with contributions and features. But before jumping into the change list, there’s a note in the release of MongoDB 2.7.7 a few days ago that is worth celebrating:

New Tools!
– The MongoDB tools have been completely re-written in Go
– Moved to a new repository: https://github.com/mongodb/mongo-tools
– Have their own JIRA project: https://jira.mongodb.org/browse/TOOLS

So far this is part of an unstable release of the MongoDB server, but it implies that if the experiment works out every MongoDB server release will be carrying client tools developed in Go and leveraging the mgo driver. This extends the collaboration with MongoDB Inc. (mgo is already in use in the MMS product), and some of the features in release r2014.10.12 were made to support that work.

The specific changes available in this release are presented below. These changes do not introduce compatibility issues, and most of them are new features.

Fix in txn package

The bug would be visible as an invariant being broken, and the transaction application logic would panic until the txn metadata was cleaned up. The bug does not cause any data loss nor incorrect transactions to be silently applied. More stress tests were added to prevent that kind of issue in the future.

Debug information contributed by the juju team at Canonical.

MONGODB-X509 auth support

The MONGODB-X509 authentication mechanism, which allows authentication via SSL client certificates, is now supported.

Feature contributed by Gabriel Russel.

SCRAM-SHA-1 auth support

The MongoDB server is changing the default authentication protocol to SCRAM-SHA-1. This release of mgo defaults to authenticating over SCRAM-SHA-1 if the server supports it (2.7.7 and later).

Feature requested by Cailin Nelson.

GSSAPI auth on Windows too

The driver can now authenticate with the GSSAPI (Kerberos) mechanism on Windows using the standard operating system support (SSPI). The GSSAPI support on Linux remains via the cyrus-sasl library.

Feature contributed by Valeri Karpov.

Struct document ids on txn package

The txn package can now handle documents that use struct value keys.

Feature contributed by Jesse Meek.

Improved text index support

The EnsureIndex family of functions may now conveniently define text indexes via the usual shorthand syntax ("$text:field"), and Sort can use equivalent syntax ("$textScore:field") to inject the text indexing score.

Feature contributed by Las Zenow.

Support for BSON’s deprecated DBPointer

Although the BSON specification defines DBPointer as deprecated, some ancient applications still depend on it. To enable the migration of these applications to Go, the type is now supported.

Feature contributed by Mike O’Brien.

Generic Getter/Setter document types

The Getter/Setter interfaces are now respected when unmarshaling documents on any type. Previously they would only be respected on maps and structs.

Feature requested by Thomas Bouldin.

Improvements on aggregation pipelines

The Pipe.Iter method will now return aggregation results using cursors when possible (MongoDB 2.6+), and there are also new methods to tweak the aggregation behavior: Pipe.AllowDiskUse, Pipe.Batch, and Pipe.Explain.

Features requested by Roman Konz.

Decoding into custom bson.D types

Unmarshaling will now work for types that are slices of bson.DocElem in an equivalent way to bson.D.

Feature requested by Daniel Gottlieb.

Indexes and CommandNames via commands

The Indexes and CollectionNames methods will both attempt to use the new command-based protocol, and fallback to the old method if that doesn’t work.

GridFS default chunk size

The default GridFS chunk size changed from 256k to 255k, to ensure that the total document size won’t go over 256k with the additional metadata. Going over 256k would force the reservation of a 512k block when using the power-of-two allocation schema.

Performance of bson.Raw decoding

Unmarshaling data into a bson.Raw will now bypass the decoding process and record the provided data directly into the bson.Raw value. This significantly improves the performance of dumping raw data during iteration.

Benchmarks contributed by Kyle Erf.

Performance of seeking to end of GridFile

Seeking to the end of a GridFile will now not read any data. This enables a client to find the size of the file using only the io.ReadSeeker interface with low overhead.

Improvement contributed by Roger Peppe.

Added Query.SetMaxScan method

The SetMaxScan method constrains the server to only scan the specified number of documents when fulfilling the query.

Improvement contributed by Abhishek Kona.

Added GridFile.SetUploadDate method

The SetUploadDate method allows changing the upload date at file writing time.

por niemeyer em 13 de October de 2014 às 09:25

October 09, 2014

Eric Hideki

imagem1

Mais uma série de links que indico:

Captura de tela de 2014-10-09 18:31:33

 

 

Vídeo aulas gratuitas de Python, PHP, Ruby e outros – Tá cansado de ficar indicando um link atrás do outro para aquele seu amigo que está aprendendo a programar? E se juntasse tudo em um lugar só? Então por esse ‘mini-projeto’ foi criado.

Conselhos de um velho programador antissocial e ranzinza – Um depoimento interessante sobre o que os programadores enfrentam diariamente, estimativas, ânimos e muitas outras coisas.

Jogo do Dragon Ball com Pygame - Já imaginou criar um jogo do Dragon Ball, e ainda mais com Python? Pois é, criaram.

imagem1

Discover Flask – Agora você não tem mais desculpa falando que não há vídeo-aulas de Flask de qualidade e atualizadas.

Django, Flask ou Pyramid? Qual escolher? - Quais são as vantagens, desvantagens e características de cada uma.

Como me tornar desenvolvedor Python? – Sabe aquela pergunta que você sempre encontra em grupos ou fóruns de Python em como entrar na área de Python? Então, o Vinícius Assef resolve essa pergunta.

Como ordenar listas em Python

0

Gerenciando Assets com Django Pipeline

Agora o mega tutorial de Flask está na versão Python 3

Contruindo uma aplicação de análise em Flask


por Eric Hideki em 09 de October de 2014 às 21:28

October 08, 2014

Magnun Leno

A História do Python

Julgo que a história do Python é extremamente importante para a comunidade, pois ela além de mostrar fatos importantes da linguagem, explica algumas de suas características e como seus desenvolvedores lutaram para manter esse projeto um dentro dos moldes do Software Livre e Open Source (antes mesmo de existir esse ...

A História do Python é um artigo original de Mind Bending

por Magnun em 08 de October de 2014 às 17:21

October 07, 2014

Kodumaro

Inception

4525295943286785564630898738613180402752865746514908141289658206399306834966472673922031069344230677865113693205407878709601660268
[]’s

por noreply@blogger.com (ℭacilhας, ℒa ℬatalema) em 07 de October de 2014 às 18:21

October 03, 2014

Filipe Saraiva

Cantor: novas funcionalidades no KDE 4.14

KDE 4.14 foi lançado em agosto de 2014, mas até o momento não tive tempo para escrever sobre as novas funcionalidades do Cantor disponíveis naquele release.

Portanto, vamos corrigir isso agora!

Novo backend: Lua

A família de backends do Cantor tem um novo membro: Lua, usando a implementação luajit.

Este backend já dispõe de várias funcionalidades: destaque de sintaxe, auto-complementação de código, carrega figuras no terminal, editor de scripts, e mais

Cantor + Lua em ação

O backend para Lua foi desenvolvido pelo brasileiro Lucas Negri, e isso é um motivo para eu ficar muito feliz. Bem-vindo a bordo Lucas!

Você pode ler mais sobre esse backend em um texto no blog do Lucas.

Uso de utf8 em códigos LaTeX

Quando você exporta seu terminal para LaTeX, a codificação utf8 agora é utilizada por padrão. Essa melhoria foi desenvolvida por Lucas.

Suporte à extensão pacotes nos backends para Sage e Octave

Agora estes backends tem um assistente para importar pacotes/módulos/bibliotecas.

Suporte para scripts que executam automaticamente

python2_autorun

Scripts para execução automática no backend para Python 2

Agora os backends para Python 2, Scilab, Octave, Sage, Maxima, Qalculate, e KAlgebra tem suporte para execução automática de scripts. Você pode configrar uma série de scripts ou comandos que serão executados no momento em que o Cantor carregar o terminal – ou seja, durante a inicialização.

Adicionado CTRL+Space como alternativa padrão à complementação de código no terminal

O comando padrão para complementação de código no terminal do Cantor é o botão TAB, mas agoras temos uma alternativa a isso: CTRL + Space. Isso manterá a consistência entre o editor de scripts (onde o comando padrão para essa funcionalidade é CTRL + Space) e o terminal.

Suporte inicial para os assistentes de algebra linear e criação de gráficos no Python 2

Desenvolvi um suporte inicial para dois plugins legais no backend para Python 2: algebra linear e criação de gráficos.

Primeiro, vamos ver o plugin de algebra linear. Na barra de menu, vá em Algebra Linear > Criar Matriz. Uma janela para criação de matrizes será aberta. Você deve então colocar os valores nas células.

python3_linearalgebraAssistente de criação de matriz

Após clicar no botão ‘Ok’, o comando para criação de matrizes da biblioteca numpy será carregado no terminal, automaticamente.

python2_linearalgebra_resultNova matriz criada

Por agora este plugin tem implementado apenas o suporte para criação de matrizes.

Veremos agora o plugin para criação de gráficos, que serve tanto para gráficos 2D quanto 3D. Façamos x = numpy.arange(0.0, 2.0, 0.01) e, na barra de menu, vamos em Gráfico > Gráfico 2D. A janela abaixo será aberta.

python2_graphicAssistente para criação de gráficos 2D

Você pode configurar uma expressão para o eixo Y (neste caso estou usando a função seno numpy.sin) e uma váriável ou função para o eixo X (neste caso, 2 * x * numpy.pi). Você poderia apenas colocar x no nome da variável para criar um gráfico dos valores de x.

Após pressionar ‘Ok’, o comando usando pylab será carregado no terminal para criar o gráfico.

python2_graphic_resultO assistente para gráficos 3D segue um padrão similar para criar as figuras.

Como você pode ver, utilizar esses assistentes requer alguns módulos do python carregados na área de trabalho, e eles devem ter os mesmos nomes utilizados nos plugins. Existem diversas formas de carregar módulos no ambiente python (import foo; import foo as [anyname]; from foo import *; etc), então fazer isso de forma genérica é praticamente impossível (na verdade eu queria ouvir algumas sugestões sobre isso da comunidade).

Minha escolha foi carregar numpy, scipy, matplotlib e pylab quando o backend para Python 2 é carregado pelo Cantor. Bem, eu pretendo mudar isso porque esses módulos passam a ser obrigatórios para o backend funcionar corretamente, e também porque pylab não é mais recomendado nas versões recentes do matplotlib. Então, eu espero alterar esse plugin o quanto antes.

De qualquer forma, gostaria de escutar as opiniões da comunidade de usuários de python no ambiente científico sobre essas funcionalidades.

Futuro

No momento estamos trabalhando no port do Cantor para Qt5/KF5. Você pode acompanhar esse trabalho no branch ‘frameworks‘ do repositório do Cantor.

Doações

Se você usa ou aprecia meu trabalho no Cantor, ou em algum outro projeto de software livre, por favor considere fazer uma doação para mim: assim eu poderei continuar me dedicando à contribuições e melhorias nesses projetos.

Você poderia considerar uma doação para o KDE também, e ajudar com a manutenção dessa grande comunidade de software livre e os projetos desenvolvidos por ela.

por Filipe Saraiva em 03 de October de 2014 às 14:56

September 30, 2014

Eric Hideki

pymap

animated_3d_python_powered_logo120frame_apng_by_metallicow-d6rdza2

Python é uma das tecnologias que mais cresce o número de adeptos, seja devido a sua popularidade em universidades(USP e Federais no Brasil, além da Fatec São José dos Campos), seja por grandes empresas usarem extensivamente em seus produtos(Instagram, Google, Disney), ou principalmente pela sua facilidade de aprendizado e poder.

Uma das coisas que mais chama atenção dos programadores é que trabalhando com Python você não fica limitado apenas ao desenvolvimento web, existem diversas outras áreas em que Python é presente e muitas vezes não temos conhecimentos de suas aplicações.

pymap

No ano passado a Pycursos teve a iniciativa do mutirão Python, no qual tivemos diversos convidados das mais diversas áreas para falar sobre o que estão trabalhando. No site do Aprenda Python temos alguns compilados de vídeos tutoriais. Exemplo 1, Exemplo 2.

E o mais curioso que a cada dia se descobre uma nova aplicação totalmente fora do padrão. Por exemplo: Você sabia que nos metrôs de São Paulo, o software que processa aquelas notícias selecionadas que aparecem nos monitores tem Python por trás? Ou senão os banners elétricos que ficam em alguns pontos também é utilizado a mesma tecnologia. Ou senão que é muito utilizado para tratamento de imagens em grandes e-commerces como a Dafiti e Netshoes? Grande maioria das imagens do produtos são automaticamente tratadas com a biblioteca Pil.

E também que Python é amplamente usado na computação ciêntífica, trabalhando em paralelo com Numpy, Scipy e outras. Vejamos mais algumas aplicações interessantes:

Python para trabalhos tipográficos:

Python para reconhecimento facial:

Python para reconhecimento de caracteres para deficientes visuais:

http://www.nvaccess.org/

Python para Biologia:

http://biopython.org/wiki/Main_Page

Python para Química:

http://www.pymolwiki.org/index.php/Main_Page

Python para análise digital de sinais:

Python para gerenciamento de estoques:

http://www.stoq.com.br/

Python para análise em tempo real de trending topics do twitter no futebol:

http://www.sentibol.com/

Python para ensino com Arduíno:

https://garoa.net.br/wiki/Garoa_Dojo_Shield

Python para educação:

http://www.qmagico.com.br/
http://www.geekie.com.br/

Python para análise de clima/tempo:

http://www.forecastwatch.com/

Python para mineração de dados e jornalismo:

Python para animações Disney:

http://pydanny-event-notes.readthedocs.org/en/latest/socalpiggies/20110526-wda.html

Python para telecomunicações:

http://www.evolux.net.br/

Python para desenvolvimento mobile:

http://kivy.org/

Python para trabalhos impressos:

https://www.layar.com/

Python para análise de características de Whiskies:

http://whiskyton.herokuapp.com/

Python para filtros RSS:

http://filterss.herokuapp.com/

Python for Small acts manifesto:

http://smallactsmanifesto.org/

E você, conhece mais aplicações? Deixe nos comentários que deixarei mais atualizado possível, ou senão indique de forma mais rápida nesse formulário.


por Eric Hideki em 30 de September de 2014 às 22:21

September 26, 2014

Gustavo Niemeyer

Packing resources into Go qml binaries

The qml package is right now one of the best choices for creating graphic applications under the Go language. Part of the reason why this is true comes from the convenience of QML, a high-level domain-specific language that allows describing visual components, events, animations, and content in general in a succinct and pleasing way. The integration of such a language with Go means having both a good mechanism for describing visual content, and a good platform for doing general development under, which can range from simple data manipulation to involved OpenGL content rendering.

On the practical side, one of the implications of using such a language partnership is that every Go qml application will have some sort of resource content to deal with, carrying the QML logic. Such content may be loaded either from files on disk, or from strings in memory. Loading from a file means the content may be organized in multiple files that directly reference each other without changing the Go application, and may be updated and tested without rebuilding. Loading from a string in memory means the content needs to be self-contained, but results in a standalone binary (linking aside – still depends on Qt libraries).

There’s a well known trick to have both benefits at once, though, and the basic solution has already been made available in multiple packages: have the content on disk, and use an external tool to pack it up into a Go file that is built into the binary when the content is updated. Unfortunately, this trick alone is not enough with the qml package, because the QML engine needs to know what resources are available and where so that the right thing happens when it sees a directory being imported or an image path being referenced.

To solve that problem, the qml package has been enhanced with functionality that leverages the existing Qt resource system to pack content into the binary itself. Rather than using the upstream C++ and XML-based resource compiler, though, a new resource packer was implemented inside the qml package and made available both under a friendly Go API, and as a tool that follows common Go idioms.

The help text for the genqrc tool describes it in detail:

Usage: genqrc [options] <subdir1> [<subdir2> ...]

The genqrc tool packs all resource files under the provided subdirectories into
a single qrc.go file that may be built into the generated binary. Bundled files
may then be loaded by Go or QML code under the URL "qrc:///some/path", where
"some/path" matches the original path for the resource file locally.

Starting with Go 1.4, this tool may be conveniently run by the "go generate"
subcommand by adding a line similar to the following one to any existent .go
file in the project (assuming the subdirectories ./code/ and ./images/ exist):

    //go:generate genqrc code images

Then, just run "go generate" to update the qrc.go file.

During development, the generated qrc.go can repack the filesystem content at
runtime to avoid the process of regenerating the qrc.go file and rebuilding the
application to test every minor change made. Runtime repacking is enabled by
setting the QRC_REPACK environment variable to 1:

    export QRC_REPACK=1

This does not update the static content in the qrc.go file, though, so after
the changes are performed, genqrc must be run again to update the content that
will ship with built binaries.

The tool may be installed via go get as usual:

go get gopkg.in/qml.v1/cmd/genqrc

and once the qrc.go file has been generated, the main qml file may be
loaded with logic equivalent to:

component, err := engine.LoadFile("qrc:///path/to/file.qml")

The loaded file can in turn reference any other content that was bundled
into the Go binary.

For a better picture, this example demonstrates the use of the tool.

por niemeyer em 26 de September de 2014 às 19:42

September 25, 2014

Magnun Leno

Shellshock, o Novo Heartbleed?

Um bug (CVE-2014-7169 e CVE-2014-6271) descoberto por Stephane Chazelas no Bash está causando uma enorme preocupação na Internet, alguns estão colocando este bug lado a lado com o Heartbleed. Mas um bug em um shell deveria causar tanta preocupação assim? O Shell não passa ser executado apenas após você se autenticar no servidor via SSH ou FTP e outros serviços? Sim… e não.

Shellshock

Shellshock, o Novo Heartbleed? é um artigo original de Mind Bending

por Magnun em 25 de September de 2014 às 19:03

September 24, 2014

Filipe Saraiva

Mês do Contribuidor KDE: …para o Akademy

Nas últimas semanas tive um intenso “mês do contribuidor KDE” que começou com o LaKademy, a conferência latinoamericana, e terminou com o Akademy, a conferência mundial. Foi um mês um tanto cansativo, de muito trabalho, mas que também foi repleto de boas histórias, grandes reencontros, novos contatos, descobertas e, por que não dizer, divertido.

No artigo anterior falei sobre o LaKademy, e agora comentarei o que rolou no Akademy.

O LaKademy havia terminado apenas um dia antes e lá estava eu, novamente pegando ônibus à São Paulo e me preparando para uma viagem que levaria por volta de 35 horas até Brno, contando com uma escala inusitada em Dubai e um ônibus de Praga, a capital da República Checa, até a cidade do evento.

Chegando à Brno chamou-me atenção a bela arquitetura de cidade antiga do leste europeu, algo exótico para nós brasileiros. Durante o evento pude vez ou outra me aventurar pela cidade, principalmente em algumas noites para jantar e no Day Trip, e consegui apreciar com calma os detalhes de vários prédios, museus, o castelo, e a catedral da cidade.

Esse Akademy foi o segundo que participei, se contarmos o Desktop Summit em 2011. Dessa vez estava como membro do KDE e.V., a organização que gerencia a parte burocrática/política do KDE, portanto minha primeira atividade foi participar da assembleia geral.

Me encantou a maneira como dezenas de contribuidores de diferentes lugares do mundo e linhas de atuação estavam ali, discutindo o futuro do KDE, planejando passos importantes para o projeto, verificando as contas da entidade, enfim, fazendo um trabalho típico de qualquer associação. Achei também impressionante a longa salva de palmas que Cornelius Schumacher, integrante do Board do KDE e.V. desde 2002 e ex-presidente da associação, recebeu dos presentes, uma maneira de demonstrar gratidão por todo o trabalho que ele realizou nesses mais de 10 anos na direção da entidade.

Para finalizar o dia teve uma recepção aos participantes na Red Hat, que me impressionou pelo tamanho da empresa na cidade (três grandes prédios). Lá pudemos tomar cervejas do país e distribuímos um pouco da cachaça brasileira. =)

IMG_20140905_193708

O dia seguinte iniciou a fase das palestras, das quais destaco o keynote do Sascha (que acredito ter sido convidado para o Akademy após o Kevin Ottens ter assistido a palestra dele aqui no Brasil durante o FISL desse ano), e a palestra sobre o GCompris, um software que admiro bastante pela pegada direcionada às crianças. Infelizmente, uma das palestras que queria ter assistido não ocorreu, que foi a Cofunding KDE aplications. Em seguida tivemos o David Faure falando sobre ports para o KF5, e mais para o fim do dia uma apresentação dos grupos do KDE da Índia e Taiwan.

No segundo dia de palestras teve o curioso keynote do Cornelius que apresentou um pouco da história do KDE a partir de imagens de antigos contribuidores do projeto. Os destaques desse dia também foram as apresentações do pessoal do VDG, o grupo que está fazendo um belo trabalho de design no Plasma 5 e agora estão estendendo o alcance do ponteiro dos seus mouses para as próprias aplicações do KDE.

Outra apresentação interessante foi sobre Next Generaion of Desktop Applications, do Alex Fiestas, onde ele argumentou que os softwares da nova geração precisam combinar informações provenientes de diferentes serviços da internet, de forma a prover ao usuário uma experiência única. Ele usou alguns exemplos de aplicações desse tipo, e estou muito curioso para experimentar o Jungle, player de vídeo que terá essas características.

Finalizando este dia tivemos a palestra do Paul Adams, muito instigante, mostrando que após investigação no repositório do KDE podemos perceber que o grau de contribuição entre os desenvolvedores diminuiu com a passagem do SVN para o GIT, que o número de commits caiu, etc. Paul tem interessantes trabalhos nessa área, mas de minha parte acho que se faz necessário outros aportes para explicar isso, inclusive para entendermos se isso é algo necessariamente ruim. Talvez hoje estejamos mais especializados do que antes? Talvez a baixa dos commits seja apenas resultado da estabilização da base de código durante esse tempo? Algo que ainda não concluímos no KDE é entendermos que passamos de um grande projeto unificado (inclusive a nível de repositório) para uma grande comunidade de subprojetos (hoje nós somos meio como a Apache). Nesse cenário, cabe fazermos comparações com o que somos hoje com o que fomos ontem, baseado apenas nos nossos repositórios? De qualquer forma, é um bom ponto para refletirmos.

Já na fase dos BoFs, participei nas primeiras duas partes do voltado à documentação de software – um trabalho importante e necessário, e que todos nós desenvolvedores poderíamos dar um pouco mais de atenção -; FOSS em Taiwan e KDE Edu na India. Infelizmente não pude comparecer ao de empacotadores (bem, eu faço empacotamento no Mageia), porque chocou com o de Taiwan. Fica para a próxima. =)

No geral gosto de ver as experiências dos grupos de usuários/desenvolvedores em outros países; a parte gerencial dessas atividades me atrai, principalmente porque podemos aplicar uma ou outra no Brasil. Saí desse Akademy com o desejo de preparar algo sobre a América Latina para o próximo evento. Acredito que temos muito a compartilhar com a comunidade sobre o que andamos fazendo por aqui, nossos erros e acertos, e qual a contribuição dos latinoamericanos para o projeto.

Finalmente, nos demais dias continuei trabalhando no port do Cantor para KF5 ou estava conversando com diferentes colaboradores do projeto pelos corredores da universidade.

Para mim é muito importante participar do Akademy pois nele eu consigo visualizar a extensão do software livre e seus contribuidores, e como essa cultura da colaboração reúne gente tão diferente em prol do desenvolvimento e evolução de programas de computador livres. Portanto, gostaria imensamente de agredecer ao KDE e.V. pela oportunidade e dizer que me sinto muito bem em fazer parte dessa grande comunidade que é o KDE. =)

E o melhor de tudo é rever o pessoal e conhecer novas pessoas. A hora em que aquele endereço de e-mail ganha contornos de face humana é um momento muito especial para nós que trabalhamos “tão próximos e tão distantes”, para usar esse chavão bastante verdadeiro. Portanto, foi muito bom estar com todos vocês pessoas!

Foto da comunidade KDE no Akademy 2014 – aqui em tamanho gigante

E fica meu desejo de bom trabalho ao novo Board do KDE e.V.!

Quem tiver interesse, boa parte das palestras está com vídeo e slides neste link.

por Filipe Saraiva em 24 de September de 2014 às 20:49

Mês do Contribuidor KDE: Do LaKademy…

Nas últimas semanas tive um intenso “mês do contribuidor KDE” que começou com o LaKademy, a conferência latinoamericana, e terminou com o Akademy, a conferência mundial. Foi um mês um tanto cansativo, de muito trabalho, mas que também foi repleto de boas histórias, grandes reencontros, novos contatos, descobertas e, por que não dizer, divertido.

Nesse artigo irei falar do LaKademy, e no próximo comentarei o que rolou no Akademy.

logoazul_menor

A segunda edição do LaKademy ocorreu em São Paulo, uma das maiores cidades da América Latina, no Centro de Competência em Software Livre da USP, um prédio inteiro dedicado à estudos e pesquisas sobre vários aspectos do software livre: licenças, engenharia de software, métricas extraídas de repositórios, aspectos sociais da colaboração, e mais.

Nesta edição coube a mim e à Aracele fazermos todos os ajustes da organização do evento, e acredito que cumprimos bem o objetivo de prover toda a estrutura necessária para termos bons dias de trabalho em locais agradáveis e confortáveis.

No primeiro dia tivemos uma série de palestras dos colaboradores, e uma das que mais me chamaram atenção foi do Rafael Gomes sobre o sysadmin do KDE. É impressionante o tamanho da estrutura que está nos bastidores, uma sólida base que permite aos desenvolvedores realizarem seu trabalho. Taí um campo que seria interessante divulgarmos mais para tentarmos atrair possíveis colaboradores que preferem esse lado da computação.

14923088670_415cfc44df_z

Nesse dia eu também apresentei uma palestra sobre Qt no Android, descrevendo como configurar o ambiente no Linux, apresentando um Hello World básico, e comentando sobre diversos softwares já disponíveis que usam essa tecnologia, em especial o VoltAir e o GCompris. Segue abaixo a apresentação

.

No segundo dia tivemos um mini-curso sobre Qt, apresentado pelo Sandro Andrade. Impressionante a didática dele e como consegue prender nossa atenção durante um dia inteiro sem ficar enfadonho ou cansativo. Meu trabalho nesse dia foi mais auxiliar os demais participantes, em especial aqueles que estavam tendo contato com Qt pela primeira vez.

Os terceiros e quartos dias foram dedicados ao hacking de aplicações e desenvolvimento de projetos. Eu dei uma força no multirão para portar o Bovo para KF5, iniciei o desenvolvimento de um metapacote para instalar todo o KF5 no Mageia, e comecei a portar o Cantor para KF5. Também trabalhei na reconfiguração dos bots do KDE Brasil nas redes sociais, uma pendência que tínhamos já há algum tempo.

15106702121_ff87d73880_z

Força-tarefa-multirão trabalhando no Bovo

No quarto dia também tivemos uma reunião para discutir algumas iniciativas de promoção do KDE na América Latina, e começamos a usar o Kanboard do KDE TODO para organizar a execução desses projetos.

Além do trabalho tivemos momentos de descontração no evento, como quando fomos visitar um dos principais hackerspaces de São Paulo, o Garoa Hacker Clube numa atividade que chamamos de Konvescote; e também quando fomos todos para a Augusta, uma das famosas ruas boêmias da cidade.

15086717746_ec5d444223_z

KDE + Garoa

Entretanto, como aliás em todos os eventos do KDE Brasil, o melhor de tudo foi reencontrar os amigos e conhecer outros novos que estão chegando ao barco. Para os últimos, que sejam todos bem-vindos e vamos arregaçar as mangas! Para os primeiros, que tenhámos ainda uma boa estrada pela frente nessa ideia de escrever software livre e, de alguma forma, retribuir para o mundo algo como programas de alta qualidade técnica e que respeitam o usuário.

O KDE Brasil escreveu um excelente review enumerando o que a comunidade produziu durante o evento, sugiro a todos que queiram ainda mais informações a darem uma olhadinha lá.

E fica meu agradecimento ao KDE e.V. por proporcionar esse encontro! Espero ver muito mais contribuidores no próximo LaKademy!

por Filipe Saraiva em 24 de September de 2014 às 16:02

CineUFSCar apresenta: The Internet’s Own Boy: The Story of Aaron Swartz

Pra você que está em São Carlos, logo mais teremos a apresentação do documentário “The Internet’s Own Boy: The Story of Aaron Swartz“, sobre a, infelizmente, curta trajetória do ciberativista Aaron Swartz.

Após o documentário teremos um bate-papo comigo, Aracele Torres (FFLCH/USP) e o prof. João Massarolo (UFSCar) tanto sobre Aaron quanto sobre demais temas retratados no documentário: os movimentos sociais em rede, as pautas, as táticas de luta, outros protagonistas que também merecem destaque, acesso aberto ao conhecimento, compartilhamento, copyright, software livre, e muito mais.

Esperamos vocês!

Serviço
Nome: CineUFSCar apresenta: The Internet’s Own Boy: The Story of Aaron Swartz
Local: Anfiteatro Bento Prado Jr
Horário: 19:00
Data: 24/09/2014
Endereço: Rodovia Washington Luís, km 235 – SP-310, próximo da Biblioteca Comunitário da UFSCar
Sessão gratuita: Sim
Para maiores informações: www.cinema.ufscar.br
Realização: UFSCar, CCult, ProEx, GEMInIS

por Filipe Saraiva em 24 de September de 2014 às 15:51

September 22, 2014

Gustavo Niemeyer

Announcing yaml v2 for Go

There were a few long standing issues in the yaml.v1 package which were being postponed so that they could be done at once in a single incompatible change, and the time has come: yaml.v2 is now available.

Besides these incompatible changes, other compatible fixes and improvements were performed in that push, and those were also applied to the existing yaml.v1 package so that dependent applications benefit immediately and without modifications.

The subtopics below outline exactly what changed, and how to adapt existent code when necessary.

Type errors

With yaml.v1, decoding a YAML value that is not compatible with the Go value being unmarshaled into will silently drop the offending value without notice. In many cases continuing with degraded behavior by ignoring the problem is intended, but this was the one and only option.

In yaml.v2, these problems will cause a *yaml.TypeError to be returned, containing helpful information about what happened. For example:

yaml: unmarshal errors:
  line 3: cannot unmarshal !!str `foo` into int

On such errors the decoding process still continues until the end of the YAML document, so ignoring the TypeError will produce logic equivalent to the old yaml.v1 behavior.

New Marshaler and Unmarshaler interfaces

The way that yaml.v1 allowed custom types to implement marshaling and unmarshaling of YAML content was slightly confusing and troublesome. For example, considering a CustomType with a keys field:

type CustomType struct {
        keys map[string]int
}

and supposing the goal is to unmarshal this YAML map into it:

custom:
    a: 1
    b: 2
    c: 3

With yaml.v1, one would need to implement logic similar to the following for that:

func (v *CustomType) SetYAML(tag string, value interface{}) bool {
        if tag == "!!map" {
                m := value.(map[interface{}]interface{})
                // ... iterate/validate/convert key/value pairs 
        }
        return goodValue
}

This is too much trouble when the package can easily do those conversions internally already. To fix that, in yaml.v2 the Getter and Setter interfaces are both gone and were replaced by the Marshaler and Unmarshaler interfaces.

Using the new mechanism, the example above would be implemented as follows:

func (v *CustomType) UnmarshalYAML(unmarshal func(interface{}) error) error {
        return unmarshal(&v.keys)
}

Custom-ordered maps

By default both yaml.v1 and yaml.v2 will marshal keys in a stable order which is increasing within the same type and arbitrarily defined across types. So marshaling is already performed in a sensible order, but it cannot be customized in yaml.v1, and there’s also no way to tell which order the map was originally in, as some applications require.

To fix that, there is a new pair of types that support preserving the order of map keys both when marshaling and unmarshaling: MapSlice and MapItem.

Such an ordered map literal would look like:

m := yaml.MapSlice{{"c", 3}, {"b", 2}, {"a", 1}}

The MapSlice type may be used for variables going in and out of the yaml package, or in struct fields, map values, or anywhere else sensible.

Binary values

Strings in YAML must be valid UTF-8 or UTF-16 (with a byte order mark for the latter), and for binary data the specification defines a standard !!binary tag which represents the raw data encoded (encrypted?) as base64. This is now supported both in yaml.v1 and yaml.v2, transparently. That is, any string value that is not valid UTF-8 will be base64-encoded and appropriately tagged so that it roundtrips as the same string. Short strings are inlined, while long ones are automatically broken into several lines and represented in a proper style. For example:

one: !!binary gICA
two: !!binary |
  gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgI
  CAgICAgICAgICAgICAgICAgICAgICAgICAgICA

Multi-line strings

Any string that contains new-line characters (‘\n’) will now be encoded using the literal style. For example, a value that would before be encoded as:

key: "line 1\nline 2\nline 3\n"

is now encoded by both yaml.v1 and yaml.v2 as:

key: |
  line 1
  line 2
  line 3

Other improvements

Besides these major changes, some assorted minor improvements were also performed:

  • Better handling of top-level “null”s (issue #35)
  • Marshal base 60 floats quoted for YAML 1.1 compatibility (issue #34)
  • Better error on invalid map keys (issue #25)
  • Allow non-ASCII characters in plain strings (issue #11).
  • Do not catch unrelated panics by mistake (commit a6dc653f)

For obtaining the yaml.v1 improvements:

go get -u gopkg.in/yaml.v1

For updating to yaml.v2, adapt the code as necessary given the points above, replace the import path, and run:

go get -u gopkg.in/yaml.v2

por niemeyer em 22 de September de 2014 às 21:35

Magnun Leno

Software Freedom Day DF

Olá pessoal! Vocês provavelmente notaram que tudo anda meio parado por aqui. Isto ocorreu pois eu estava focado em preparar 2 palestras para o evento SFD-DF (Software Freedom Day - Distrito Federal), uma sobre VIM e outra sobre Pelican.

Software Freedom Day

Software Freedom Day DF é um artigo original de Mind Bending

por Magnun em 22 de September de 2014 às 18:31

September 12, 2014

Allison Azevedo

Allisson

Nesse vídeo eu mostro como eu configuro meu ambiente de desenvolvimento no OSX Mavericks.


por Allisson Azevedo em 12 de September de 2014 às 17:15

September 05, 2014

Magnun Leno

Hack ‘n’ Cast v0.5 - Por Que Usar GNU/Linux

Hoje, com a presença de dois convidados apresentamos um episódio muito mais sóbrio sobre alguns motivos (vantagens e algumas desvantagens) para se usar GNU/Linux.

Baixe o episódio e leia o shownotes

por Magnun em 05 de September de 2014 às 23:20

September 02, 2014

Álvaro Jüsten

Curso de Arduino em Belo Horizonte

Curso de Arduino em BH

Já faz algum tempo que eu gostaria de fazer o Curso de Arduino em Belo Horizonte - adoro Minas (estou sempre por lá) e sempre tem mineiros me perguntando sobre o curso. Então, chegou o momento: estão abertas as inscrições para turma do Curso de Arduino em BH! \o/

O curso acontecerá em parceria com o Guajajaras Coworking, um espaço de trabalho super moderno, com ótimas pessoas e muito bem localizado, no Centrão da cidade (Rua dos Guajajaras, 572).

Curso de Arduino no Guajajaras Coworking

A primeira turma de BH acontecerá em dois sábados, dias 20 e 27 de setembro, das 10 às 19 horas (com 1h de intervalo para almoço), totalizando 16 horas de aula.

Se você tem interesse, corre porque a procura está grande: recebi centenas de e-mails perguntando por essa turma! Só temos 16 vagas e já temos 50% da turma inscrita (abrimos as inscrições há apenas 5 dias). O valor da inscrição é de R$ 450,00, que podem ser pagos em até 12x usando o PagSeguro. Inscreva-se já no Curso de Arduino em BH.

Vou aproveitar o tempo em Minas e tentar participar de um pyBHar, o encontro dos pythonistas mineiros! ;-)

Arduinistas e Pythonistas mineiros, até lá! o/

por noreply@blogger.com (Álvaro Justen "Turicas") em 02 de September de 2014 às 16:37

September 01, 2014

Elcio Luiz Ferreira

Instale no seu Chrome: Todoist for Gmail

Todoist for Gmail
Você está praticando Inbox Zero, certo? E precisa de um jeito fácil de transformar um e-mail num to-do em sua lista.

Instale a extensão Todoist for Gmail. Claro, se você usa Todoist. Se não usa, é um bom momento para avaliar

O post Instale no seu Chrome: Todoist for Gmail apareceu primeiro em fechaTag.

por elcio em 01 de September de 2014 às 14:52

August 31, 2014

Christiano Anderson

Introdução à Programação com Python – Resenha

Introdução à Programação com Python

Introdução à Programação com Python

Recebi da Editora Novatec um exemplar do livro “Introdução à Programação com Python“, do Nilo Ney Coutinho Menezes. Fiz a leitura do livro e abaixo vou publicar minha opinião a respeito.

O livro não é voltado apenas a iniciantes na linguagem Python mas também para quem quer se aprofundar  na versão 3 desta linguagem, que possui alterações significativas em comparação com a versão 2. O autor utiliza uma linguagem clara e precisa, com exemplos práticos e uma excelente didática. Aborda todos os aspectos da linguagem, desde uma introdução aos conceitos básicos até assuntos mais elaborados, como orientação a objetos, classes e algoritmos.

Para quem quer mergulhar em Python e procura um ótimo material de referência, capaz de guiar por todas as etapas da linguagem, é uma excelente escolha, sendo que estou indicando esse livro para meus alunos.

Os exemplos possuem uso de alguns algoritmos, embora simples, incentivam o leitor a conhecer melhor e entender o uso adequado e boas práticas da linguagem. Aborda também alguns exemplos de conexão com banco de dados, no caso, SQLite, mas a mesma lógica pode ser utilizada para outros bancos de dados relacionais.

Entre os pontos positivos, destaco a linguagem clara e precisa do autor, sabe conduzir muito bem o leitor a um mergulho completo a todos os principais aspectos da linguagem Python, mesmo quem nunca teve nenhum contato com a linguagem.

Entre os pontos negativos, na verdade nem seria um ponto negativo, mas uma sugestão, seria ter alguns exemplos de conexão com bancos não relacionais, como MongoDB, que está cada vez mais popular.

Cupom de desconto

Consegui um desconto de 20% para meus leitores em todo site da Novatec, válido até o fim do ano. Se você quiser comprar esse título ou qualquer outro do site, basta inserir o código “CHRISTIANO” no carrinho de compra e seu desconto será calculado automaticamente! :)

O post Introdução à Programação com Python – Resenha apareceu primeiro em Christiano Anderson.

por Christiano Anderson em 31 de August de 2014 às 16:34

August 29, 2014

Gustavo Niemeyer

The new Go qml OpenGL API

As detailed in the preliminary release of qml.v1 for Go a couple of weeks ago, my next task was to finish the improvements in its OpenGL API. Good progress has happened since then, and the new API is mostly done and available for experimentation. At the same time, there’s still work to do on polishing edges and on documenting the extensive API. This blog post aims to present the improvements made, their internal design, and also to invite help for finishing the pending details.

Before diving into the new, let’s first have a quick look at how a Go application using OpenGL might look like with qml.v0. This is an excerpt from the old painting example:

import (
        "gopkg.in/qml.v0"
        "gopkg.in/qml.v0/gl"
)

func (r *GoRect) Paint(p *qml.Painter) {
        width := gl.Float(r.Int("width"))
        height := gl.Float(r.Int("height"))
        gl.Enable(gl.BLEND)
        // ...
}

The example imports both the qml and the gl packages, and then defines a Paint method that makes use of the GL types, functions, and constants from the gl package. It looks quite reasonable, but there are a few relevant shortcomings.

One major issue in the current API is that it offers no means to tell even at a basic level what version of the OpenGL API is being coded against, because the available functions and constants are the complete set extracted from the gl.h header. For example, OpenGL 2.0 has GL_ALPHA and GL_ALPHA4/8/12/16 constants, but OpenGL ES 2.0 has only GL_ALPHA. This simplistic choice was a good start, but comes with a number of undesired side effects:

  • Many trivial errors that should be compile errors fail at runtime instead
  • When the code does work, the developer is not sure about which API version it is targeting
  • Symbols for unsupported API versions may not be available for linking, even if unused

That last point also provides a hint of another general issue: portability. Every system has particularities for how to load the proper OpenGL API entry points. For example, which libraries should be linked with, where they are in the local system, which entry points they support, etc.

So this is the stage for the improvements that are happening. Before detailing the solution, let’s have a look at the new painting example in qml.v1, that makes use of the improved API:

import (
        "gopkg.in/qml.v1"
        "gopkg.in/qml.v1/gl/2.0"
)

func (r *GoRect) Paint(p *qml.Painter) {
        gl := GL.API(p)
        width := float32(r.Int("width"))
        height := float32(r.Int("height"))
        gl.Enable(GL.BLEND)
        // ...
}

With the new API, rather than importing a generic gl package, a version-specific gl/2.0 package is imported under the name GL. That choice of package name allows preserving familiar OpenGL terms for both the functions and the constants (gl.Enable and GL.BLEND, for example). Inside the new Paint method, the gl value obtained from GL.API holds only the functions that are defined for the specific OpenGL API version imported, and the constants in the GL package are also constrained to those available in the given version. Any improper references become build time errors.

To support all the various OpenGL versions and profiles, there are 23 independent packages right now. These packages are of course not being hand-built. Instead, they are generated all at once by a tool that gathers information from various sources. The process can be tersely described as:

  1. A ragel-based parser processes Qt’s qopenglfunctions_*.h header files to collect version-specific functions
  2. The Khronos OpenGL Registry XML is parsed to collect version-specific constants
  3. A number of tweaks defined in the tool’s code is applied to the state
  4. Packages are generated by feeding the state to text templates

Version-specific functions might also be extracted from the Khronos Registry, but there’s a good reason to use information from the Qt headers instead: Qt already solved the portability issue. It works in several platforms, and if somebody is using QML successfully, it means Qt is already using that system’s OpenGL capabilities. So rather than designing a new mechanism to solve the same problem, the qml package now leverages Qt for resolving all the GL function entry points and the linking against available libraries.

Going back to the example, it also demonstrates another improvement that comes with the new API: plain types that do not carry further meaning such as gl.Float and gl.Int were replaced by their native counterparts, float32 and int32. Richer types such as Enum were preserved, and as suggested by David Crawshaw some new types were also introduced to represent entities such as programs, shaders, and buffers. The custom types are all available under the common gl/glbase package that all version-specific packages make use of.

So this is all working and available for experimentation right now. What is left to do is almost exclusively improving the list of function tweaks with two goals in mind, which will be highlighted below as those are areas where help would be appreciated, mainly due to the footprint of the API.

Documentation importing

There are a few hundred functions to document, but a large number of these are variations of the same function. The previous approach was to simply link to the upstream documentation, but it would be much better to have polished documentation attached to the functions themselves. This is the new documentation for MultMatrixd, for example. For now the documentation is being imported manually, but the final process will likely consist of some automation and some manual polishing.

Function polishing

The standard C OpenGL API can often be translated automatically (see BindBuffer or BlendColor), but in other cases the function prototype has to be tweaked to become friendly to Go. The translation tool already has good support for defining most of these tweaks independently from the rest of the machinery. For example, the following logic changes the ShaderSource function from its standard from into something convenient in Go:

name: "ShaderSource",
params: paramTweaks{
        "glstring": {rename: "source", retype: "...string"},
        "length":   {remove: true},
        "count":    {remove: true},
},
before: `
        count := len(source)
        length := make([]int32, count)
        glstring := make([]unsafe.Pointer, count)
        for i, src := range source {
                length[i] = int32(len(src))
                if len(src) > 0 {
                        glstring[i] = *(*unsafe.Pointer)(unsafe.Pointer(&src))
                } else {
                        glstring[i] = unsafe.Pointer(uintptr(0))
                }
        }
`,

Other cases may be much simpler. The MultMatrixd tweak, for instance, simply ensures that the parameter has the proper length, and injects the documentation:

name: "MultMatrixd",
before: `
        if len(m) != 16 {
                panic("parameter m must have length 16 for the 4x4 matrix")
        }
`,
doc: `
        multiplies the current matrix with the provided matrix.
        ...
`,

and as an even simpler example, CreateProgram is tweaked so that it returns a glbase.Program instead of the default uint32.

name:   "CreateProgram",
result: "glbase.Program",

That kind of polishing is where contributions would be most appreciated right now. One valid way of doing this is picking a range of functions and importing and polishing their documentation manually, and while doing that keeping an eye on required tweaks that should be performed on the function based on its documentation and prototype.

If you’d like to help somehow, or just ask questions or report your experience with the new API, please join us in the project mailing list.

por niemeyer em 29 de August de 2014 às 14:17

August 25, 2014

Filipe Saraiva

Minha lista TODO para o LaKademy 2014

logoazul_menor

Nesta semana em São Paulo, uma das maiores cidades deste planeta, sediará a segunda Conferência Latino Americana do KDE – ou, como chamamos, o LaKademy!

O evento ocorrerá no Centro de Competência em Software Livre da Universidade de São Paulo, um lugar interessante onde academia, empresas, e comunidades, trabalham juntas para criar, melhorar, e pesquisar sobre software livre.

Neste evento, a comunidade Latino Americana do KDE tentará algo novo: teremos apresentações sobre particularidades do KDE. Em eventos específicos do KDE por aqui, é mais comum termos apenas sessões de hacking, enquanto as apresentações e mini-cursos são ofertados nos eventos de software livre mais gerais. Desta vez nós organizamos um evento aberto para não-contribuidores do KDE, e talvez ao final eles se tornem contribuidores do projeto.

A programação do evento tem vários assuntos: arte, port de softwares do GTK para Qt (um potencial flamewar), KDE Connect, e mais. Eu apresentarei um tutorial introdutório sobre C++ + Qt + KDE no Android. O principal caso de estudos será o GCompris, e será interessante mostrar um software cujo o mesmo code pode ser compilado e executado no Linux e no Android. Também apresentarei outros softwares: liquidfun, uma biblioteca C++ para simulação de fluídos (que tem uma demo muito massa no Android); VoltAir, um jogo desenvolvido em QML pelo Google para o Android (e open source!); e talvez KAlgebra, mas eu preciso compilá-lo ainda.

Sim, isso é C++ e QML no Android!

Para as sessões de hacking eu reservarei um tempo para estudar o port do Cantor para Qt5/KF5; é hora de começar esse trabalho. Ainda sob esse tópico, pretendo conversar com os amigos do KDE sobre um software para auxílio de escrita de artigos científicos… mas bem, espere por novidades no próximo ano. =) Farei também algum trabalho com os bots do KDE Brasil que funcionam nas redes sociais, corrigindo alguns bugs, etc.

Para as reuniões, espero discutir sobre as ferramentas de comunidação que temos (e minha proposta é usar o KDE todo para auxiliar no gerenciamento de nossas ações), e contribuir com a avaliação das ações do KDE Brasil no nosso país. Desde o pultimo LaKademy (2012, Porto Alegre), nós continuamos a promover o KDE nos eventos de software livre, e pudemos trazer vários contribuidores do KDE para o Brasil. Agora é hora de pensarmos em mais e novas atividades para realizarmos.

Mas LaKademy não é apenas sobre trabalho. Nós teremos algumas atividades culturais também, como o Konvescote no Garoa Hacker Club, um hackerspace em São Paulo, e algumas cervejas para bebermos na Vila Madalena. Mais importante, estou muito feliz em rever os amigos do KDE de novo (Brasil, por que tão grande?).

Estamos trabalhando para fazer um LaKademy fantástico esse ano! Fique de olho no Planet KDE e no Planet KDE Português para acompanhar mais notícias diretamente do evento!

Vejo você no LaKademy!

(ou no Akademy, mas isso é história para um outro post :) )

imgoingtoLakademytamanhopequeno

por Filipe Saraiva em 25 de August de 2014 às 14:26

Kodumaro

Combinador de ponto fixo

GliderA beleza da matemática e do cálculo é que algo não precisa ter uma aplicação prática imediata para ser estudado em profundidade. A aplicabilidade pode surgir 150, 200 anos após sua concepção.

Um dos tópicos mais magníficos do cálculo-λ é o combinador de ponto fixo, apesar de ser de interesse mais acadêmico do que diretamente prático.

Ainda assim, seu entendimento engrandece em tamanha proporção o conhecimento do programador, que vale a pela dedicar-lhe algum tempo.

Conceitos básicos

Há alguns pré-requisitos que você precisa conhecer para começar nosso estudo:

Cálculo-λ

Cálculo-λ é uma parte da lógica matemática criada da década de 1930 como parte da investigação dos fundamentos da matemática. No cálculo-λ, todos os elementos são funções de primeira classe, inclusive os números.

Por exemplo, o número 2 é uma função que aplica uma outra função duas vezes, e é representado como λsz.s(sz).

O sinal + (ou S em alguns textos) significa incremento, e é descrito como λwyx.y(wyx). Ou seja, +3 é 3 incrementado, que é igual a 4. 2+3 é a função 2 recebendo como parâmetros + e 3, ou seja, incrementa duas vezes o número 3, +(+3), o que resulta em 5.

A multiplicação é prefixal, não mesoclítica, ou seja, 2x escreve-se como *2x (ou M2x) e sua definição é λab.a(b+)0 ou λxyz.x(yz).

O cálculo-λ é o princípio de onde deriva a programação funcional.

[update 2014-08-25]
A definição de decremento é (caso eu não tenha copiado errado):
DEC = λnfx.n (λgh.h(gf)) (λu.x) I
[/update]

Ponto fixo

Impossível entender combinador de ponto fixo sem saber o que significa ponto fixo. Ponto fixo é o ponto de uma função onde o valor retornado é igual ao valor fornecido.

Por exemplo, dada a função f(x) = 2x-1, o que em notação cálculo-λ fica f = λx.DEC(*2x), o ponto fixo é aquele onde fx = x, ou seja, o resultado é igual ao parâmetro.

Usando aritmética básica:
f(x) = 2x - 1
x = 2x - 1
2x - 1 = x
2x - 1 - x = 0
x - 1 = 0
x = 1

Portanto o ponto fixo de λx.DEC(*2x) é 1.

Repare que a recursão sobre o ponto fixo resulta sempre no mesmo resultado. Se:
x = fx

Podemos substituir x por fx:
x = fx = f(fx) = f(f(fx))) = ...


Variáveis livres e vinculadas

Em cálculo-λ, no corpo de uma função, todas as variáveis que vêm de sua assinatura são vinculadas e as que vêm de fora são livres.

Por exemplo, na função:
λfx.Δxf


As variáveis x e f são vinculadas e a variável Δ é livre.

Combinadores

Combinadores são funções que não possuem variáveis livres. Por exemplo:
λx.xx
λx.y

A primeira linha é um combinador, já a segunda não.

Veja que, a rigor, números e operadores aritméticos são variáveis livres, porém, como são valores constantes e bem definidos, tratam-se de exceções aceitáveis em um combinador.

Construção let

A construção let é uma construção clássica em cálculo-λ e em linguagens funcionais de programação.

Darei um exemplo: seja fx igual a *2x em f4, o resultado é 8 – fx é o dobro e x e o caso é f4. Isso é descrito assim:
let fx = *2x in f4

Podemos construir uma função assim, por exemplo, dado o parâmetro x, sendo fa igual a *2a em fx-1:
λx.let fa = *2a in DEC(fx)

É o mesmo que:
λx.DEC(*2x)

Em Haskell isso pode ser escrito assim:
func x = let f a = 2 * a in f x - 1

Em Racket fica assim:
(describe func
(λ (x)
(let ((f (λ (a) (* 2 a)))
(- (f x) 1))))

A forma genérica da construção let é:
let fx = y in z

E sua abertura é:
(λf.z)(λx.y)


Finalmente: o combinador de ponto fixo

Combinador de ponto fixo é uma função que retorna o ponto fixo da função fornecida como parâmetro. Em cálculo e mesmo em programação isso é muito útil na implementação de funções recursivas.

Função recursiva é aquela que faz chamada a ela mesma, por exemplo, fatorial:
FACT = λn.(ISZERO n) 1 (*n (FACT (DEC n)))

Olhando para o corpo da função, mesmo desconsiderando números e operadores (ISZERO, 1, * e DEC), ainda há a variável livre FACT, que não é definida na assinatura da função.

[update 2014-08-25]
A definição de ISZERO é:
TRUE = λxy.x
FALSE = λxy.y
ISZERO = λn.n(λx.FALSE)TRUE
[/update]

A forma de resolver isso é criar uma função que recebe a si mesma na assinatura:
ALMOST-FACT = λfn.(ISZERO n) 1 (*n (f (DEC n)))

Quando esse combinador recebe como parâmetro o fatorial, ele retorna o próprio fatorial, assim a função fatorial é o ponto fixo dele!

O combinador de ponto fixo é aquele que, ao receber a função como parâmetro, retorna seu ponto fixo – e quando a função recebe o ponto fixo, retorna o próprio ponto fixo, segundo o seguinte comportamento:
yf = f(yf)

Só aqui já seria possível implementar uma função que calcule o ponto fixo. Em Haskell:
fix f = f (fix f)

E em Lazy Racket:
(define fix
(λ (f)
(f (fix f))))

Porém seria sem sentido, pois essa mesma função que resolve o problema, é parte do problema, já que ela própria possui variável livre.

Resolver este problema não é difícil: basta pegarmos a definição: dada uma função f, queremos o ponto x onde fx seja igual a x… é uma construção let!

Data uma função que recebe f (λf.), seja x igual a fx (let x = fx) em x (in x):
λf.let x = fx in x

De fato isso já funciona em Haskell:
fix :: (a -> a) -> a
fix f = let x = f x in x


Combinador Y

Para Scheme (Lazy Racket), precisamos destrinchar um pouco mais, abrindo o let.

Precisamos de dois parâmetros na primeira posição, portanto dobraremos o x:
λf.let x = fx in x
λf.let xx = f(xx) in xx
λf.(λx.xx)(λx.f(xx))

Mais um passo e chegamos ao famoso combinador Y de Curry!

Aplicando o parâmetro λx.f(xx) à função λx.xx, temos (λx.f(xx))(λx.f(xx)), exatamente o combinador Y de Curry:
Y = λf.(λx.f(xx))(λx.f(xx))

Em Lazy Racket:
(define Y
(λ (f)
((λ (x) (f (x x))) (λ (x) (f (x x))))))


Linguagens estritas

A maioria das linguagens não suporta lazy evaluation, então é preciso fazer um truque para que a definição do combinador não entre em loop infinito.

O truque é aplicar a função λsv.sv (que é o número 1, equivalente à identidade: I = λx.x). Por exemplo:
g = 1g
g = (λsv.sv) g
g = (λv.gv)

Por exemplo, o combinador Y em Python:
Y = lambda f: (lambda x: x(x))(lambda x: f(x(x)))

Esse código entra em loop infinito! Mas se substituirmos xx por λv.xxv, tudo se resolve:
Y = lambda f: (lambda x: x(x))(lambda x: f(lambda *args: x(x)(*args)))


Outros combinadores de ponto fixo

Curry foi o que obteve a solução mais simples para o combinador de ponto fixo, mas não foi o único. Há outras soluções possíveis.

Combinador de Turing:
Θ = (λx.xx)(λab.b(aab))


Combinador de ponto fixo estrito (vimos acima):
Z = λf.(λx.xx)(λx.f(λv.xxv))

Combinador de ponto fixo não padrão:
B = λwyx.w(yx)
∆ = λx.xx
N = B∆(B(B ∆)B)

[]’s

por noreply@blogger.com (ℭacilhας, ℒa ℬatalema) em 25 de August de 2014 às 00:55

August 23, 2014

Artificial Intelligence in Motion

MIP, my proposal for a high-performance analysis pipeline for whole exome sequencing



Hi all,

It has been a while since my last post, but the reason is worth the long time absent. Since January I am co-leading the bioinformatics and I.T department of one of Genomika Diagnósticos

Genomika is one of most advanced clinical genetics laboratory in Brazil. Located in Recife, Pernambuco, in the Northeast of Brazil, it provides cutting edge molecular testing in cancer samples to better define treatment options and prognosis, making personalized cancer management a reality. It also has a vast menu of tests to evaluate inherited diseases, including cancer susceptibility syndromes and  rare disorders. Equipped with state-of-the-art next-generation sequencing instruments and a world-class team of specialists in the field of genetic testing, Genomika focus on test methods that improve patient care and have immediate impact on management.  There is available a pitch video about our lab and one of our exams (unfortunately the spoken language is portuguese).

Our video about sequencing exams spoken in portuguese

My daily work is to provide tools; infra-structure and systems to support our clients and teams in the lab. One of major teams is the molecular biology sector. It is responsible for the DNA sequencing exams, which includes targeted-panels, specific genes or exons or whole exome.  Each one of those genetic tests, before delivered to the patient and the doctor,  goes under several data pre-processing and analysis steps organised in a ordered set of sequential steps, which we call a pipeline.

There is a customised pipeline for clinical sequencing; where we bioinformaticians and specialists study the genetic basis of human phenotypes. In our lab pipeline we are interested on selecting and capturing the protein-coding portion of the genome (we call the exome).  This region responsible for only 3% of our human DNA can be used to elucidate the genetic causes of many human diseases, starting from single gene disorders and moving on more complex genetic disorders, including complex traits and cancer.

Clinical Sequencing Pipeline overview


For this task,  we use several tools that must handle with large volumes of data, specially because of the new next-generation DNA sequencing machines (yeah we have one at our lab from Illumina). Those machines are capable of producing in shorter times and lower costs  large amount of NGS data. 

Taking those challenges into account, we perform our sequencing, alignment, detection and data analysis of human samples in order to seek variants.  This study we call variant analysis. Variant analysis looks for variant information, that is, possible mutations that may be associated to genetic diseases . Let's consider as examples of mutation or variant as follows: a change of nucleotide (A for T) (single nucleotide variant or SNV) or even a small insertion or deletion (INDEL's) that can impact the functional activity of the protein.  Looking after variants and even further seek and identify those related to diseases or genetic disorders is a big challenge in terms of technology, tools and interpretation.

The reference in the genome at bottom; the variants above.
In this example there's a possible exchange of A to G (SNV) in a specific position of the genome.


In our lab we are developing a streamlined, highly automated pipeline for exome and targeted panel regions data analysis. In our pipeline we handle multiple datasets and state of the art tools that are integrated in a custom pipeline for generating, annotating and analyzing sequence variants.

We named our internal pipeline tool as MIP (Mutation Identification pipeline). Some minimal requirements we stablished for MIP in order to use it with maximum performance and productivity. 

1. It must be automatic;  with a limited team like ours (2 or 3 bioinformaticians) we need a efficient service that is capable to execute the complete analysis without typing commands at terminals calling software or converting files among several data formats.

MIP pipeline overview for clinical sequencing. All those steps requires tools and files in a specific format.
Our engine   would be capable of manage and execute all or some of those steps with
specific parameters defined by the specialist .

2. It must be user-oriented; it mean that MIP platform must provide an easy-to-use interface, that any researcher of lab could use the system and start out-of-box their sequencing analysis.  For biologists and geneticists it would allow them to focus their work on what matters: the downstream experiments.

3. Scalable-out architecture;  More and more hight throughput sequencing data is pulled out from NGS instruments, so MIP must be designed to be a building block for a scalable genomics infrastructure. It means that we must work with distributed and parallel approaches and the best practices from high-performance computing and big data to efficient take advantage of all resources available at our infra-structure while thinking on continuous optimization in order to minimize the network and shared disk I/O footprint.

My draft proposal to our exome sequencing pipeline

4. Rich-detailed reports and smart software and dataset updates;  In order to maintain our execution engine working healthy, it requires that our software stack always being updated. Since our engine is written on top of numerous open-source biological and big data packages, we need a self-contained management system that could not only check for any new versions but also with a few clicks start any update and perform a post-check for any possible corruptions at the pipeline.  In addition to the third-party genomics software used on MIP, we are also developing our tool for variant annotation. So it stands for an engine that could query and analyze several genomic dataset, generate real-time interactive reports where the researchers could filter out variants based on specific criteria and output in formats of QC reports, target and sequencing depth information, descriptions of the annotations and variants hyperlinked to public datasets in order to get further details about a variation.

Example of web interface where a researcher could select any single or combination of annotations to display. Links to the original datasources are readily available (Figure from WEP annotation system)

5. Finally, we think the most important requirement nowadays to MIP is the integration with our current LMS (Laboratory management system), in order to put the filtered variants  as input to our existing laboratory report analysis and publishing workflow. It means more productivity and automation with our existing infrastructure.

MIP could be also be acessible via RESful API, where the runs output
 would be interchanged with our external LMS solution.

As you may see, there's a huge effort on coding, design and infrastructure to meet those requirements. But we are thrilled to make this happen!  One of our current works in this project is the genv tool. Genv is what we call our genomika environment builder. The basic idea behind it is a tool written in python and fabric package, that provides instant access to biological software, programming libraries and data. The expected result  is a fully automated infrastructure that installs all software and data required to start MIP pipeline.  We are thinking of also arranging pre-built images with Docker.  Of course I will need a whole post to explain more about it!

To sum up,  I hope I could summarise one of the projects I've been working this first semester. At Genomika Diagnósticos we are facing big scientific challenges and the best part is that those tools are helping our lab to provide a next level of health information to the patients,  all from our DNA!

If you are interested on working with us, keep checking our github homepage with any open positions at our bioinformatics team.

Until next time!

por Marcel Caraciolo (noreply@blogger.com) em 23 de August de 2014 às 18:50

August 19, 2014

Elcio Luiz Ferreira

oh-my-zsh: shell esperto com zsh e open source

Estamos publicando, e anunciando em nossa lista de e-mails, o Mini-curso gratuito de Linux para Programadores. Recebi no final da semana passada o seguinte e-mail:

Olá Elcio,

olha, como já sou usuário Linux já sabia algumas coisas do que foi dito, mas outras não. Achei a forma que desenvolveu esse vídeo bem interessante, prático e objetivo, sem muita balela, o que acho ótimo pois tem uns cursos por aí que os instrutores ficam de muito blábláblá. Por essa primeira aula vejo que aprenderei bem mais no decorrer do curso. São 4 partes, né?

Uma coisa que notei é que está usando zsh. Vão rolar umas dicas de como usar ele ou vai continuar só no bash mesmo? É que por coincidência acabei de instalar ele e ainda estou apanhado um cadim, rsrs.
Bem, é isso. Parabéns pela iniciativa e fico no aguardo das próximas aulas.

Abraços,

******** *****

Como eu faço? oh-my-zsh

Como achei que a resposta podia ser útil para mais gente, resolvi publicar aqui. Eu uso o oh-my-zsh.

Uso com o tema padrão mesmo. No meu .zshrc só tem de personalizado uns alias de comando e definição do PATH e CDPATH. Faço a instalação com o instalador automático. Ele já vem com coisas como um plugin de git que mostra o branch atual e o status no prompt.

Recomendo oh-my-zsh. É o zsh em sua melhor forma, sem esforço. Veja um exemplo do meu shell, com o prompt sinalizando o status do repositório git atual e quando um comando falhou:

oh-my-zsh

Quer aprender mais sobre o terminal do Linux? Veja nosso Mini Curso Grátis sobre Terminal.

O post oh-my-zsh: shell esperto com zsh e open source apareceu primeiro em fechaTag.

por elcio em 19 de August de 2014 às 03:14

August 18, 2014

Eric Hideki

ericstk

Nessa sexta-feira tivemos a primeira edição do mesa de bar com Python – https://plus.google.com/u/0/events/cbns01fg1is9e01snivvm3g4310

O intuito desse bato papo era encurtar distâncias e criar novos laços com pessoas do Brasil inteiro. As conversas foram muito bacanas, e o intuito que isso se torne algo mais frequente e interativo, por isso criei esse pequeno formulário de 1 minuto para que vocês possam opinar e melhorar as próximas edições.


por Eric Hideki em 18 de August de 2014 às 17:35

August 14, 2014

Magnun Leno

Testando Contribuições ao Mind Bending

Quando anunciei que o blog estava aberto a contribuições por meio de pull-requests no GitHub, eu ainda não havia concluído a documentação sobre como realizar testes e previsões. Sim o Hack ‘n’ Cast estava tomando muito tempo!

Mind Bending Blog

Bem, agora está tudo documentado e utilizando o Pelican 3.4 (sua versão mais recente). Boa parte deste processo está documentado aqui

Testando Contribuições ao Mind Bending é um artigo original de Mind Bending

por Magnun em 14 de August de 2014 às 18:27

August 13, 2014

Gustavo Niemeyer

Announcing qml v1 for Go

After a few weeks of slow progress on the qml package for Go, action is starting again.

The first important change is the release of the new v1 API, which is motivated by conversations and debugging sessions we’ve had at GopherCon back in April. The problem being solved is that Mac OS requires its graphic activities to be held in the first thread in the running process, and that’s incompatible with the API provided by the qml package in v0.

In practice, code in v0 looked like this:

func main() {
        qml.Init(nil)
        engine := qml.NewEngine()
        ...
}

This interface implies that logic must continue running in the initial goroutine after the GUI initialization is performed by qml.Init. Internally qml.Init will spawn a goroutine which will take over a process thread to hold the main GUI loop, and this works fine in most OSes, and used to work okay in Mac OS too, probably by chance (there’s a chance the thread locked up is the first one), but recently it started to fail more consistently and enabled the problem to be more clearly spotted and solved.

The solution requires a minor incompatible change. In v1, the initialization procedure takes the following form:

func main() {
        err := qml.Run(run)
        ...
}

func run() error {
        engine := qml.NewEngine()
        ...
}

This subtle change allows the qml package to deterministically take over the initial process thread for running the GUI loop, and is all that needs to change for an application to be initialized under the new API.

This issue also affects testing, but qml.Run isn’t suitable in those cases because the “go test” machinery doesn’t provide an appropriate place for calling it. As a good workaround, the GUI loop may be setup from an init function within any *_test.go file with:

func init() { qml.SetupTesting() }

With that in place, all tests can assume the GUI loop is running and may then use the qml package functionality arbitrarily.

Besides these changes related to initialization, the v1 API will also hold a new GL interface that is still being worked on. The intention was to have that interface ready by the announcement date, but developing the new API in an isolated branch is hindering collaboration on the new package, and is also unfortunate for people that depend on the Mac OS fixes, so v1 is being released with an unstable gl package under the path "gopkg.in/qml.v1/work-in-progress/gl". This package will suffer significant changes in the coming weeks, so it’s best to avoid publishing any applications that depend on it before it is moved to the final import path.

The package source code, documentation, and import path are referenced from gopkg.in, and to talk about any of these changes please join the mailing list.

Thanks to Andrew Gerrand for the help debugging and testing the new initialization procedure.

por niemeyer em 13 de August de 2014 às 22:12

August 11, 2014

Eric Hideki

py13

Ao ver os resultados que a Lidiane Monteiro apresentou sobre sua pesquisa da comunidade Python brasileira foi um sinal para mim. Sinal dos pontos que devem ser louvados, tanto quanto pontos a serem melhorados. Analisando slide por slide é possível tirar diversas conclusões, e algumas delas não diretamente a Python, e sim a área de TI em geral.

Em cada slide irei colocar MINHAS OPINIÕES a respeito, sinta de a vontade para criticar, concordar ou ressaltar, até porque discussões de pontos de vista são uma excelente forma de aprendizado conjunto ;).

Gênero

Python: Passado, presente, futuro - Part: 1

Infelizmente isso é um número geral em todas as áreas de TI. Ainda há quem sabe um dia que acabe o machismo, brincadeiras nocivas e descriminação do sexo feminino em relação a área de exatas. Vide esse artigo:

http://blog.msoledade.com.br/?p=205

TODAS as mulheres com quem tive contato já falaram que pelo menos uma vez na vida sofreu preconceito no local de trabalho, por isso existem iniciativas sensacionais para que esse cenário mude. Se caso não conhece, veja esses projetos fantásticos:

http://www.luluzinhacamp.com/

http://pyladiesnatal.github.io/

http://mulheresnacomputacao.com/

http://rodadahacker.com/

http://inspiradanacomputacao.wordpress.com/

http://www.pyladies.com/

http://railsgirls.com/

Uma das premissas do código de conduta do Python é que visa o respeito e a diversidade de tudo e todos. Isso é um dos motivos de gostar da linguagem, construir um ambiente inclusivo no qual todos possam ser equivalentes, em que o respeito seja o pilar de qualquer relação entre as pessoas.

Esses números são tristes, a área poderia ser muito mais rica, diversificada e repleta de evoluções se esse tipo de coisa não acontecesse. Mas isso não acontece só na área de TI, acontece de forma geral, até porque em muitos casos é tão verdade que a mulher recebe menos do que o homem, mesmo executando os mesmos serviços.

Novamente, ainda bem que existem iniciativas de pessoas como a Lucia Freitas, Camila Archutti, Daniela Silva e diversas outras pessoas que se esforçam diariamente para contornar a situação.

Escolaridade

py2

Esse gráfico mostra diversos pontos interessantes. Ter como a grande maioria pessoas de Superior Incompleto são estudantes, ou seja, são pessoas que estão aprendendo a programar. A outra fatia grande do gráfico são pessoas com Superior Completo. Então temos a leve ideia de que a maioria das pessoas no Brasil que estão mexendo com Python são pessoas na faixa entre 18~25 anos, então haverá uma grande safra de pessoas com conhecimentos em Python dentro de alguns anos no mercado.

Já as pessoas com Superior Completo são a maioria do qual já trabalham há algum tempo com programação, fora os níveis acima como Pós-graduação, Mestrado e Doutorado, que por um lado é ruim termos poucas pessoas com esses níveis.

Acredito que isso venha da cultura brasileira no qual o curso Superior é o suficiente. Até porque a grande maioria entra na faculdade com intuito de ingresso no mercado de trabalho, sendo que o requisito mínimo seja o Superior Completo.

Concluindo, isso mostra que Python tende a crescer com o passar do tempo devido a grande maioria ser jovem.

Quantos anos programando?

py3

Olhe só, 40% das pessoas são entre 1 a 3 anos, aí entra novamente a questão dos estudantes. Já a outra maioria de 28% são as pessoas que estão dentro do mercado. E algo surpreendente é uma fatia de programadores Sênior com 16%.

Isso é bom, e algo também ruim. Bom no sentido que mais da metade das pessoas contém no mínimo 3 anos de experiência com programação. Por outro lado entra o que muitos tem reclamado: Despreparo das pessoas para preencher vagas de emprego.

E já digo na lata: Não arranja emprego na área quem não quer. Como já coloquei esse vídeo uma vez, colocarei de novo para reforçar minha tese:

“Quem quer dá um jeito, não arranja desculpa. Se não tem tempo, então está na hora de você repensar na forma como gasta suas horas. Todos temos 24 horas por dia e mesmo assim consegue fazer as coisas nas horas livres”

Para eu aprender Python, melhor ainda, aprender de forma plena como COMEÇAR a programar, levei 2 anos estudando por conta. Como também já falei em minhas palestras, tentei mais de 100 vezes nos mais diversos tipos de apostilas, aulas, tutoriais.

“Água mole em pedra dura, tanto bate até que fura.”

Quem consegue as coisas são aqueles que persistem, não que desistem ao primeiro obstáculo.

Aí novamente entra o vídeo do Bruno Tikami para a Python Brasil do ano passado: “Quer ganhar 10k por mês? Tem que ralar!”

Em que nível você está?

py4

36% são iniciantes, metade são intermediários, ou seja, a maioria que ou está tentando arranjar emprego, ou já trabalha há algum tempo. E ter apenas 14% de avançado mostra que falta gente capacitada.

O que isso significa? O mercado ainda sofrerá com as pessoas inacapacitadas, e isso sempre será. Bons profissionais são disputados e nunca faltam oportunidades, se tá faltando oportunidade para você, quer dizer que tem alguns pontos a serem melhorados.

Em que usa Python?

py5

Maioria para projetos pessoais, já a outra grande fatia como Hobby, ou seguidos de trabalhos acadêmicos.

Novamente relacionado as pessoas que estão na faculdade. Não tem como comentar muito a respeito.

Em que áreas você usa Python?

py6

Desenvolvimento web ganha disparado, isso é fácil devido a grande parte dos projetos serem desenvolvidos em Django ou Flask. Olha a outra fatia interessante de 16% que apenas estudam.

Já perceberam que os dados são muito bacanas, mas tem que levar em consideração que a grande maioria das pessoas que estão respondendo o formulário são estudantes? Não que isso seja ruim, mas não leve esses dados como verdades proporcionais absolutas.

E outro dado interessante são as diversas aplicações da linguagem em campos diferentes. Confesso que fiquei impressionado com a quantidade de aplicações Desktop e processamento de imagens.

Quais frameworks utilizados?

py7

A ordem é natural, Django é o framework mais popular do Python, devido a ser full-stack, ótima documentação e fontes de referências, seguidos de Flask, alternativa natural caso Django não atenda aos requisitos do projeto.

Web2py no Brasil está em destaque como terceiro lugar devido aos esforços das pessoas da comunidade no Brasil, como o Bruno Rocha e Elcio Ferreira escrevendo artigos e vídeos a respeito.

E os outros frameworks, tão importantes quanto os demais acima, Pyramid e Bottle são muito bacanas, outras alternativas ao Flask, caso queira, Tornado para aplicações com altas requisições, e um número engraçado, Plone em terceiro.

Plone talvez seja tão usado quanto os outros acima citados, diversos projetos brasileiros de grandes portais como os Correios, sites governamentais são feitos em Plone, então esse número seja um pouco errado.

Qual SO usa para programar Python?

py8

Esse ponto se contradiz um pouco. Grande maioria dos estudantes estão usando Windows para aprender a programar, e eles são a grande maioria nessa pesquisa.

O que significa isso?

Significa que a grande maioria está aprendendo por conta própria, saber usar sistemas Linux se torna muito mais fácil e rápido aprender Python do que Windows.

Windows em segundo lugar, então entra a questão das pessoas que tem preferência ao sistema, ou necessidade e tal. Normal.

E Mac em terceiro, provavelmente pessoas que já trabalham na área e precisam de tecnologia mais alta para trabalho.

Em que outras linguagens você programa?

py9

Isso é bacana. Ter Java e C/C++ como as linguagens principais mostra aqueles que trabalham com essas diariamente e usam Python como projetos pessoais ou Hobby.

Outro ponto como PHP, não há de negar que é mais fácil encontrar projetos PHP para dar manutenção do que Python, isso devido ao número de projetos feitos com WordPress, Joomla ou Drupal, ou até mesmo sites mais antigos.

E seguindo a ideia, vejo por exemplo que apenas 3% apenas trabalham com Python. Isso quer dizer que tem muita gente que gostaria de trabalhar com Python, mas por inúmeras razões não trabalham.

Trabalha com programação?

py10

Grande maioria sim, então isso é um ponto positivo. Mas ainda ter 42% não trabalhando quer dizer que a situação poderia ser melhor, a questão é? Quais são as razões para que não haja mais ingresso das pessoas na área de programação?

Alguma vez já trabalhou com Python?

py11

Outro número interessantíssimo. Apenas 36% já trabalharam. Menos da metade já trabalhou com Python.

Isso quer dizer que não há oportunidades?

Na verdade já me perguntei em relação a isso, as vagas de Python em grande parte necessitam de que haja experiência, mas como posso arranjar experiência se não arranjo emprego?

Projetos Open Source. Colabore e o torne como portifólio. Programador bom é aquele que expõe seu código para ser julgado, até porque julgá-lo o tornará um programador melhor.

E também estar dentro da comunidade, 75% das vagas são preenchidas antes de serem postadas em sites de emprego. Se você não está em contato com as pessoas que trabalham com Python, como é que você irá saber sobre as vagas que abrem? Como é que irão saber que você é bom se não tem código aberto para ser avaliado?

Você trabalha atualmente com Python?

py12

Novamente entra a questão, você está preparado para essas vagas? E isso não é só Python, é o mercado em geral? Tem o mínimo de conhecimento sobre testes? Controle de versão com Git? Sabe trabalhar com mais de um framework? E trabalhar com API’s?

O que o Bruno disse: “Se você não sabe, tem que correr, virar noites estudando, se esforçando para aprender.”

O que você acha da documentação de Python?

py13

Um dos pontos fortes de Python é a documentação, tanto é que a metade das pessoas o consideram boa, claro que há pontos a serem melhorados. Já a outra parte que é mais de 1/4 da pesquisa diz que é ótimo, ponto positivo.

Ter 4 pessoas dizendo que é ruim é normal, mas o que eu gostaria de saber quais são os pontos negativos que essas pessoas viram? Talvez possamos melhorar com simples mudanças.

E olha, 7% das pessoas nunca usaram a documentação. Isso novamente entra a questão dos novatos. 7% é muito alto.


 

Farei disso como primeira parte, acredito que no decorrer da semana irei lançar a continuação dos slides. Comentem, sua opinião é muito importante.


por Eric Hideki em 11 de August de 2014 às 23:54

August 10, 2014

Eric Hideki

IMG_20140809_182115416_HDR

Mais uma vez estive presente no TDC, e como não poderia deixar de prestigiar a trilha de Python. TDC é um dos maiores eventos de tecnologia que temos no Brasil, palestrantes do país inteiro vão compartilhar suas experiências e conhecimentos com a comunidade.

TDC 2014 - Trilha Python

Tive o primeiro contato com grandes pythonistas na edição anterior, conhecendo pessoalmente Bruno Rocha, Luciano Ramalho, Fernando Masanori, Francisco Souza, Thiago Avelino, Guto Maia, Osvaldo Matos Júnior e diversos outros muito importantes. Confesso que parecia uma criança amedrontada diante tamanha as feras que estavam presentes.

Ano passado foi muito bom, tivemos palestras bacanas falando de Django, Scrapy, pyNES, API pública de ceps, Flask, Tornado, Bottle e outros. E esse ano não poderia ser diferente.

Python como o tema da minha palestra diz: “O que Python pode fazer e você não sabia” em teoria foi a porta de entrada para as diversas opções e aplicações que a linguagem oferece, sendo que muitos dos temas abordados foram apresentados posteriormente.

A organização e a quantidade de trilhas que o evento tem é sensacional, tem de tudo pra todos, robótica, Java, .Net, software livre, empreendedorismo, IOT, e o mais especial desse ano, TDC4kids, uma trilha para crianças aprenderem programação com a aplicação Scratch. O evento é organizado e o local é bem localizado, então ajuda bastante o tamanho dele, o número esperado de pessoas em 4 dias de evento é por volta de 3300 pessoas.

Então irei dar minha opinião sobre as palestras que assisti e compartilhar com vocês o que foi dito.

50 minutos – Python para Zumbis: primeiro MOOC para ensino de programação brasileiro atinge 15 mil inscritos – Fernando Masanori Ashikaga

IMG_20140809_103653676_HDR

Python para Zumbis é algo enorme, tamanho imensurável o impacto que ele teve no Brasil inteiro, analisando seria que a cada 3 cidades do Brasil, 1 tinha algum zumbi estudando Python, e presente em todos os Estados do Brasil.

E é só perguntar quem já fez o curso entre os presentes da sala que metade levantou a mão. E um comentário feliz: Graças ao curso do Masanori foi possível conseguir um trabalho de Python, disse o rapaz. E algo que foi surpreendente que enquanto conversava no horário do almoço, não parava de chegar pessoas seja da trilha de Python ou outras trilhas para conversar com o Masanori fazendo perguntas, e tirando fotos seja dele ou o Drone que foi apresentado.

50 minutos – Quokka CMS – Sites e portais com Flask e MongoDB – Bruno Cezar Rocha

IMG_20140809_114629322_HDR

Quokka CMS é um projeto fantástico do Bruno, um novo CMS de banco NoSQL, em que é fácil a instalação, customização e aplicação de temas. O intuito do CMS é oferecer os diferenciais que outros CMS’s não tem, Bruno tendo experiência sobre como trabalham os CMS’s, já que ele é um dos grandes responsáveis no desenvolvimento do Opps CMS, sentiu que haviam algumas coisas que não puderam ser feitas, seja pelas características do projeto, ou do Django.

15 minutos – O que Python pode fazer e você não sabia- Eric Hideki Imai Satake

Então veio minha palestra, procurei falar sobre as possibilidades que Python oferece para quem não conhecia a linguagem, abordando a aplicação na web, trabalhando com tratamento de imagens, BioPython, Pygame e outros.

15 minutos – Processamento de tweets em tempo real com Python + Django + Celery – Miguel Galves

IMG_20140809_132933862

Criar uma aplicação trabalhando com API do Twitter é algo complicado, complicado no sentido de que o Twitter é imenso, são em média 5700 tweets por segundo, então foi comentado como poder trabalhar com essas Big Datas, como a API funciona, quais as melhores ferramentas e falar sobre a experiência de criar grandes aplicações com esse nicho.

15 minutos – APIs de visualização em Python – Wilson Freitas

IMG_20140809_135115530

Outra palestra muito bacana, mostrando como podemos usar Python para gerar gráficos a partir de informações complexas, compartilhando as características e opções que temos, seja com mpld3, matplotlib, seaborn e outros. Comentou sobre um caso de catalogação de vinhos e os resultados.

50 minutos – Ensaio sobre testes automatizados- Gustavo O. da Fonseca

IMG_20140809_141617747

TDD é fundamental na vida de um desenvolvedor, aplicando essa metodologia conseguimos construir aplicações sustentáveis, seguras e que sejam fáceis de fazer manutenção, então o Gustavo mostrou os tipos de testes que temos disponíveis, seja por testes automatizados ou unitários, mostrando as características e aplicações em casos reais.

15 minutos – Python para programadores com DDA – Pedro Palhares

Desculpe amigo, não vi essa palestra que começou mais cedo do que eu esperava e só peguei o minuto final e não assisti. Por favor quem assistiu possa comentar no post falando do que achou.

15 minutos – Prototipando Games em Python – Guto Maia

IMG_20140809_155319722_HDR

Guto é um aficcionado por games, ano passado comentou sobre seu projeto do pyNES, e então dessa vez foi mostrado as formas de você criar seus games com Pygame, quais são os atalhos que deve percorrer e dicas para que seu aprendizado seja rápido.

E um dado bem interessante é que a grande maioria das pessoas entra na faculdade com intuito de criar jogos, mas 97% desistem no meio do caminho, e apenas 3% continuam. Ou seja, é muito pouco devido ao mercado crescente, então mostrar as possibilidades que Python tem em relação a jogos foi muito bacana.

15 minutos – AudioLazy 0.6 will robotize you! – Danilo de Jesus da Silva Bellini

IMG_20140809_162634487_HDR

Audiolazy é um projeto fantástico, suas variações e possibilidades com processamento de sons é surpreendente, sendo feitos em tempo real. Aplicações como alterar o som de uma guitarra, alterar a voz de uma pessoa, parecendo um robô ou até criar um teclado sonoro.

50 minutos – Machine Learning “Gerrilha” – Felipe Cruz

IMG_20140809_164739615_HDR

Felipe era um cara que queria conhecer pessoalmente, conheço pela internet há uns 2 anos acho e pudemos finalmente trocar ideias e compartilhar experiências. E nessa visita a terra da garoa foi para falar de machine learning, ensinando como manipular datasets, mostrando técnicas de melhorar sua performance na hora do processamento, como trabalhar em nuvem com machine learning e também uma aplicação real dessas práticas em um desafio.

https://speakerdeck.com/felipecruz/machine-learning-guerrilha

15 minutos – Porque len() não é um método? – Luciano Ramalho

IMG_20140809_120933376

Luciano comenta de forma prática e rápida porque devemos usar len(s) ao invés de s.len(). Para quem não sabem len() é um método Python para saber quantos elementos estão contidos dentro de uma lista.

Por exemplo:

len(eric)

Resultado: 4 (número de letras)

E novatos tem a ideia de que se quer analisar o número de elementos, faz mais sentido fazer ‘eric.len()’ ao invés do modelo acima.

len é um método poderoso, e ele não faz análise apenas de palavras, e sim de listas, sendo assim conter a lista dentro do método faz muito mais sentido.

15/15 minutos – Scrapy Model – Modelagem fácil de web crawlers | OrientDB – No more joins!
– Bruno Cezar Rocha

IMG_20140809_180006122_HDR

Palestra dupla!

Na primeira parte foi mostrada como podemos trabalhar com buscas de termos na internet com Scrapy, dando dicas de como dribar problemas como o resultado esperado não ter sido o que desejava, ou senão quais as melhores formas de trabalhar índices.

Na segunda parte foi introduzido a ideia do OrientDB, um banco de dados orientado a grafos, algo que será ainda muito comentado. Repensando de forma diferente de como podemos criar laços entre as informações e dados, tirando diversos paradigmas que temos em bancos SQL e noSQL, e como trabalhar ele com Python.

IMG_20140809_182115416_HDR

15 minutos – Python Performance Tips – Sérgio Oliveira Campos

Infelizmente houve problemas com o Sérgio e ele não pode fazer sua apresentação.

————————————————————————————–

Em todo geral foi muito bacana, superou minhas expectativas. Assim que os slides forem disponibilizados serão atualizados o artigo.


por Eric Hideki em 10 de August de 2014 às 14:23

August 07, 2014

Elcio Luiz Ferreira

Magnun Leno

Hack ‘n’ Cast v0.4 - Introdução à Programação

Ah, A programação! A bela arte de gerar códigos! Linus Torvalds já dizia: programar é para poucos. Eu ainda acrescento: programar bem é para raríssimos. Você também não está neste seleto grupo? Então junte-se a nos e venha se divertir com esse tópico!

Baixe o episódio e leia o shownotes

por Magnun em 07 de August de 2014 às 05:04

August 05, 2014

Magnun Leno

Projeto "Aprenda a Programar"

Semana passada lendo alguns textos pelo feedly acabei vendo que o Lucas Caton (um cara que eu sigo a muito tempo) iniciou um projeto de crowdfunding chamado "Aprenda a Programar".

Código

Geralmente sou muito receoso com esse modelo, mas vindo do Lucas Caton eu já fico mais tranquilo, por isso fui checar o projeto no Catarse.

Projeto "Aprenda a Programar" é um artigo original de Mind Bending

por Magnun em 05 de August de 2014 às 21:35

August 04, 2014

Magnun Leno

TTY - Programando para o console do Linux

Outro dia eu estava desenvolvendo um programa para o GNU/Linux em modo texto e esse programa executaria algumas operações e deveria exibir o status dessa execução no terminal. Pois bem, foi aí que me deparei com algumas características interessantes do famoso "modo texto" do GNU/Linux. Acabei tropeçando também em muita história interessante que gostaria de compartilhar.

Terminal

Na verdade o correto não é modo texto, mas sim "Terminal". Terminal, Modo Texto, TTY? What the Hell?

TTY - Programando para o console do Linux é um artigo original de Mind Bending

por Fernando Almeida em 04 de August de 2014 às 16:55

Elcio Luiz Ferreira

Instale no seu Chrome: Chrome to Phone

Google Chrome to Phone AppGoogle Chrome to Phone Extension inclui um botãozinho na barra de ferramentas do Chrome que, quando clicado, abre a página atual em seu celular. O setup é bastante simples, mas você vai ter que instalar um aplicativo também em seu celular.

Simples de usar, muito útil, o aplicativo ainda guarda no telefone um histórico das URLs que você enviou entre o computador e o telefone.

O post Instale no seu Chrome: Chrome to Phone apareceu primeiro em fechaTag.

por elcio em 04 de August de 2014 às 14:40

July 29, 2014

Magnun Leno

Makefile Para Java

No artigo anterior, mostrei como realizar uma série de compilações e empacotamentos usando os utilitários do Java. Entretanto, utilizar a linha de comando constantemente para esse tipo de tarefa é um trabalho árduo.

Java & GNU

Agora que sabemos exatamente como podemos compilar um código Java e gerar seus respectivos pacotes manualmente, podemos escrever um GNU Makefile para automatizar essa tarefa.

Makefile Para Java é um artigo original de Mind Bending

por Magnun em 29 de July de 2014 às 03:56

July 21, 2014

Gustavo Niemeyer

mgo release r2014.07.21, now at gopkg.in

This is a special release of mgo, the Go driver for MongoDB. Besides the several new features, this release marks the change of the Go package import path to gopkg.in, after years using the current one based on a static file that lives at labix.org. Note that the package API is still not changing in any backwards incompatible way, though, so it is safe to replace in-use import paths right away. Instead, the change is being done for a few other reasons:

  • gopkg.in is more reliable, offering a geographically distributed replicated deployment with automatic failover
  • gopkg.in has a nice landing page with pointers to source code, API documentation, versions available, etc.
  • gopkg.in is backed by git and github.com, which is one of the most requested changes over the years it has been hosted with Bazaar at Launchpad

So, from now on the import path to use when using and retrieving the package should be:

Starting with this release, the source code is also maintained and updated only on GitHub at:

The old repository and import path will remain up for the time being, to ensure existing applications continue to work, but it’s already holding out-of-date code.

In terms of changes, the r2014.07.21 release brings the following news:

Socket pool size limit may be changed

A new Session.SetPoolLimit was added for changing the number of sockets that may be in use for the desired server before the session will block waiting for an available one. The value defaults to 4096 if unset.

Note that the driver actually had the ability to limit concurrent sockets for a long time, and the hardcoded default was already 4096 sockets per server. The reason why this wasn’t exposed via the API is because people commonly delegate to the database driver the management of concurrency for the whole application, and this is a bad design. Instead, this limit must be set to cover any expected workload of the application, and application concurrency should be controlled “at the door”, by properly restricting used resources (goroutines, etc) before they are even created.

This feature was requested by a number of people, with the most notable threads being with Travis Reader, from IronIO, and the feature is finally being added after Tyler Bunnel, from Stretchr.com, asked for the ability to increase that limit. Thanks to both, and everybody else who chimed in as well.

TCP name resolution times out after 10 seconds

Previous releases had no driver-enforced timeout.

Reported by Cailin Nelson, MongoDB.

json.Number is marshalled as a number

The encoding/json package in the standard library allows numbers to be held as a string with the json.Number type so that code can take into account their visual representation for differentiating between integers and floats (a non-standard behavior). The mgo/bson package will now recognize those values properly, and marshal them as BSON int64s or float64s based on the number representation.

Patch by Min-Young Wu, Facebook.

New GridFile.Abort method for canceling uploads

When called, GridFile.Abort cancels an upload in progress so that closing the file being written to will drop all uploaded chunks rather than atomically making the file available.

Feature requested by Roger Peppe, Canonical.

GridFile.Close drops chunks on write errors

Previously, a write error would prevent the

File">

File">

File">GridFile

file from being created, but would leave already written chunks in the database. Now those chunks are dropped when the file is closed.

Support for PLAIN (LDAP) authentication

The driver can now authenticate against MongoDB servers set up using the PLAIN mechanism, which enables authentication against LDAP servers as documented.

Feature requested by Cailin Nelson, MongoDB.

Preliminary support for Bulk API

The ability to execute certain operations in bulk mode is being added to the 2.6 release of the MongoDB server. This allows queuing up inserts, updates, and removals to be sent in batches rather than one by one.

This release includes an experimental API to support that, including compatibility with previous version of the MongoDB server for the added features. The functionality is exposed via the Collection.Bulk method, which returns a value with type *mgo.Bulk that contains the following methods at the moment:

  • Bulk.Insert – enqueues one or more insert operations
  • Bulk.Run – runs all operations in the queue
  • Bulk.Unordered – use unordered mode, so latter operations may proceed when prior ones failed

Besides preparing for the complete bulk API with more methods, this preliminary change adds support for the ContinueOnError wire protocol flag of the insert operation in a way that will remain compatible with the upcoming bulk operation commands, via the unordered mode.

The latter feature was requested by Chandra Sekar, and justifies the early release of the API.

Various compatibility improvements in user handling for 2.6

The MongoDB 2.6 release includes a number of changes in user handling functionality. The existing methods have been internally changed to preserve compatibility to the extent possible. Certain features, such as the handling of the User.UserSource field, cannot be preserved and will cause an error to be reported when used against 2.6.

Wake up nonce waiters on socket death

Problem reported and diagnosed by John Morales, MongoDB.

Don’t burn CPU if no masters are found and FailFast is set

Problem also reported by John Morales, MongoDB.

Stop Iter.Next if failure happens at get-more issuing time

Problem reported by Daniel Gottlieb, MongoDB.

Various innocuous race detector reports fixed

Running the test suite with the race detector enabled would raise various issues due to global variable modifications that are only done and only accessible to the test suite itself. These were fixed and the race detector now runs cleanly over the test suite.

Thanks to everybody that contributed to this release.

por niemeyer em 21 de July de 2014 às 21:41

Magnun Leno

Aberto a contribuições

Desde que me envolvi com o Software Livre e o mundo Open Source, acabei adotando essa filosofia e aplicando seus princípios em muitos aspectos da minha vida, e este site é só uma dessas consequências.

Software Livre - Cloud

Apesar deste site servir para manter o conhecimento que adquiro aberto e acessível para a comunidade, eu nunca tinha bolado uma boa forma de tornar o site 100% livre, isto é, aberto para outras pessoas e disponibilizado seu conteúdo sem restrições. Se você não tiver paciência para ler e quiser logo saber como contribuir, clique aqui.

Aberto a contribuições é um artigo original de Mind Bending

por Magnun em 21 de July de 2014 às 16:40

July 11, 2014

Magnun Leno

Argumentos e Parâmetros em C

Os parâmetros e argumentos são aquelas opções que usamos quando executamos um programa na linha de comando, como df -h ou ls -la --color. Tratar esses parâmetros e argumentos faz com que nossos programas estejam em compliance com o sistema operacional.

C Language

A implementação dos parâmetros e argumentos da linha de comando é um assunto complexo e requer dedicação. Abaixo explico de maneira prática como implementá-los através de funções GNU. No entanto, vou explicar também um pouco desse padrão da linha de comando, dos parâmetros e dos argumentos, pois é imprescindível saber como eles funcionam para uma correta implementação.

Argumentos e Parâmetros em C é um artigo original de Mind Bending

por Fernando Almeida em 11 de July de 2014 às 15:22

July 07, 2014

Magnun Leno

Hack ‘n’ Cast - v0.3 Introdução ao GNU/Linux

O GNU/Linux foi a mola propulsora da Internet como a conhecemos hoje e, por isso, é uma peça de tecnologia fundamental pra qualquer profissional. Hoje vamos saber um pouco de sua história, entender porquê escrevemos GNU antes de Linux e discutir um pouco sobre a disputa épica entre Linus e Tanenbaum.

Baixe o episódio e leia o shownotes

por Magnun em 07 de July de 2014 às 04:38

June 30, 2014

Magnun Leno

UNIX System Signals em Python

Após publicar o texto sobre UNIX System Signals em C, percebi que pode ter dado a impressão que apenas a linguagem C possui essa integração. Com isso, escrevi este artigo para demonstrar o mesmo mecanismo demonstrado pelo Fernando Almeida.

Zen of Python

Todo o conceito de sinais, sua dinâmica de envio e uma tabela listando todos os sinais existentes está disponível aqui. Então vamos direto para o código!

UNIX System Signals em Python é um artigo original de Mind Bending

por Magnun em 30 de June de 2014 às 21:00

June 27, 2014

Osvaldo Santana Neto

Negócios na “internet fechada”

Já faz algum tempo que acompanho o desenvolvimento de novos negócios de tecnologia ao redor no mundo. Por conta disso participei e participo de vários eventos dessa área no Brasil. Eventos onde empreendedores apresentam suas idéias, fazem seus pitches, demonstram seus produtos e buscam melhorar o seu relacionamento com outros empresários, investidores e até mesmo com seus clientes.

Nessas apresentações eu já vi todo tipo de negócio na área de tecnologia. Negócios que funcionam nos mais diversos tipos de plataformas. As plataformas mais comuns são a Web e a Mobile.

Quando um empreendedor começa a desenhar o seu modelo de negócio ele precisa pensar em diversas coisas e nesse processo ele eventualmente se coloca em uma armadilha que dei o nome de “internet fechada”. Já explico o que isso significa.

Todo mundo sabe que a internet é uma rede aberta, com padrões e protocolos abertos. Essa abertura da internet permite que você faça o que bem entender com ela (desde que não seja ilegal) sem se preocupar com nada. Na internet aberta ninguém tem poder de te censurar sem motivo razoável.

Mas existem plataformas dentro da própria Web onde existem regras mais rígidas que mudam frequentemente.

Se o empreendedor baseia toda a sua estratégia de negócio e desenvolve uma aplicação Web para o Facebook, por exemplo, ele fica sujeito às regras do Facebook. E no Facebook eles mudam essas regras o tempo todo.

O risco do Facebook inviabilizar o negócio desse empreendedor é muito alto. O empresário está lá trabalhando para aumentar a sua empresa e num dia de manhã, quando abre a sua Inbox, dá de cara com uma “Alteração nos Termos de Serviço”. Nessa alteração o Facebook proíbe ele de fazer algo essencial para atender os seus clientes.

O impacto dessa mudança nos Termos de Serviço pode até não ser fatal mas certamente vai dificultar muito as coisas para esse empresário.

Outra característica das plataformas fechadas é a de que os clientes nunca serão 100% do empresário em questão. Os clientes são da tal plataforma. Ou você acha que o Facebook vai te entregar os usuários deles?

Quando eu conversava sobre esse assunto com um amigo que desenvolve Apps para celular ele me perguntou se o mesmo não acontece nas lojas de aplicativos? Ele citou dois problemas principais: as regras mudarem de forma a impedir que sua App seja vendida na loja e o caso onde a fabricante da plataforma (ex. Android ou iOS) fornece uma App parecida com a sua integrada no aparelho.

No primeiro caso o problema é bem parecido com o da internet fechada. O segundo não.

A Apple é bem conhecida por suas mudanças de regras que levam empresas inteiras a passarem por dificuldades. Apps que promoviam outras Apps sofreram muitas restrições de funcionamento. Outras que vendiam livros, música, filmes, etc… sofreram barbaridade com a proibição de vendas a partir da App.

Pense nos empresários que investiram alto para criar esses produtos e acordaram um dia sem nada. Se a App estiver disponível para Android a coisa fica menos pior mas o impacto vai ser grande mesmo assim. No mundo do Google/Android a coisa é um pouco mais tranquila mas o risco está lá.

O segundo caso, quando uma a fabricante lança uma App similar já integrada com o SO, é diferente porque ela não proíbe você de negociar sua App.

Para resolver esse problema é só o empresário fazer a App dele ser preferida pelos seus clientes. A Apple tem o iMessage nem por isso o WhatsApp sofreu. As coisas ficam mais difíceis mas não impossíveis.

Portanto, a dica que fica para os futuros empreendedores é: não amarre o seu “core business” à internet fechada.

Integre sua aplicação com o Facebook, Twitter, etc. sem problemas. Mas faça isso de um modo onde seja possível trabalhar também de forma desacoplada: na internet aberta.

The post Negócios na “internet fechada” appeared first on osantana.

por Osvaldo Santana em 27 de June de 2014 às 02:01

June 26, 2014

Filipe Saraiva

Seminário na UNICAMP: “Tecnologias livres para o futuro”

Amanhã teremos um seminário legal reunindo uma galera legal discutindo um tema legal e espinhoso.

Quem não puder ir na Unicamp, vai ter transmissão via stream.

Esperamos vocês heim!

Tecnologias livres para o futuro

Depois de anos de lutas e sucessos, as tecnologias livres, especialmente o movimento software livre, vivem um momento singular. Em paralelo à crescente adoção por pessoas, governos, empresas e coletivos, surge um sentimento de que o próprio movimento está morrendo, diluído em estratégias corporativas, utopias sobre a comunicação em rede, dispositivos móveis e novas travas tecnológicas. A proposta desse debate é reunir pesquisadores interessados em aspectos técnicos, sociais, políticos, comportamentais e produtivos das tecnologias livres e, a partir de investigações sobre a história, as ideias e prática dessas tecnologias, buscar traçar questões e princípios que orientem reflexões sobre cenários futuros. Por que caminhos os movimentos em torno de tecnologias livres devem orientar suas lutas cotidianas de modo a fortalecer a igualdade de oportunidades, a colaboração e a justiça que fundamentam esses movimentos? A estrutura do evento privilegiará a conversa e a livre troca de ideias, com falas curtas de alguns participantes seguidas de um debate aberto.

Local: Labjor – Unicamp

Horário: das 10h às 13h e das 14h às 17h

Manhã

Rafael Evangelista: As ideologias free e open: a questão da igualdade

Miguel Said Vieira: Governança, estratégias e conflitos de interesse

A apresentação tratará de questões ligadas a governança e conflitos de interesse (entre empresas e usuários caseiros) em dois casos de software livre: o Android (e sua relação com as estratégias comerciais da Google); e os patches “ck” do kernel.

Filipe Saraiva: Software Livre – Tensões entre Movimento e Mercado

Discussão sobre as contradições de um movimento apropriado tanto por coletivos de ativistas sociais quanto por grandes empresas. A exposição se baseará principalmente na ideia da diluição de alguns aspectos ideológicos do movimento com o crescente número de usuários de software livre, e a relação entre empresas e software livre. Em seguida serão comentados alguns desafios do movimento, com foco principal na computação ubíqua.

Bruno Buys: O Movimento Software Livre no Brasil morreu? Que desafios se colocam no presente e o que podemos inferir para o futuro?

Tarde

Aracele Torres: Como a indústria do software adotou o padrão de código fechado

Uma breve história da indústria do software e como foi seu processo de inclusão no circuito de propriedade intelectual e o papel do Projeto GNU em se contrapor a isso. A ideia aqui seria discutir um pouco dessas tensões entre as demandas do mercado e as demandas sociais por acesso ao conhecimento.

Tiago Chagas Soares: Política e comunidade na emergência da Cibercultura

Um breve ensaio sobre algumas das proposições políticas e comunitárias presentes na emergência da Cibercultura. Como as noções de comunidade e autonomia individual na Cibercultura  entrelaçariam distintos vetores do pensamento político e cultural? – e como isso se manifestaria em conflitos intra e entre correntes ciberculturais? Neste debate, traremos à discussão o Forum Internacional de Software Livre (Fisl) como espaço a ilustrar esse panorama de pensamentos diversos, bem como seus componentes.

Fabrício Solagna: (vídeo) Movimento software livre, Propriedade Intelectual e direitos de internet

A exposição pretende trazer os conceitos de Kelty e Coleman sobre o movimento software livre global. Para analisar o caso brasileiro é usado Shaw e seu conceito de insurgent expertise relacionando a sua interface com a mobilização em torno do Marco Civil da Internet. O objetivo é discutir questões peculiares do Brasil onde a ascensão de quadros envolvidos com o movimento software livre dentro do Estado trazem uma nova agenda do software livre.

Vídeo

Essa atividade foi filmada e disponibilizada no Youtube. Houveram alguns problemas com a preparação da gravação e tal, mas dá pra acompanhar tranquilo e ficar por dentro do que rolou.

por Filipe Saraiva em 26 de June de 2014 às 19:37

June 25, 2014

Magnun Leno

UNIX System Signals em C

Sempre que desenvolvo programas, tento saber as regras básicas de cada sistema operacional. Os motivos? Bem, por dois simples motivos: Compatibilidade e Praticidade

C - The Programming Languagen

Compatibilidade porque esses programas, para serem considerados compatíveis, devem obedecer as regras e práticas do sistema operacional alvo. Essa compatibilidade também pode ser chamada de compliance. Praticidade porque muito do que o programador precisa já existe no sistema operacional. Nada de reinventar a roda!

UNIX System Signals em C é um artigo original de Mind Bending

por Fernando Almeida em 25 de June de 2014 às 18:51

June 24, 2014

Eric Hideki

flask

armin_ronacher_pythonistas_que_voce_devia_conhecer

Armin Ronacher é o responsável por criar o Flask, microframework web Python mais famoso, tendo features interessantes como integração para testes únicos, usa Jinja2 templates, base unicode, extensa documentação e ótima comunidade em volta. Nomeado membro da PSF em 2012 como forma de reconhecimento pelas suas colaborações na comunidade Python.

E hoje iremos falar um pouco sobre esse framework e a história e projetos do criador.

Armin é um dos fundadores do team Pocoo, um grupo de pessoas da comunidade Python que trabalham em diversos aplicações e bibliotecas Python, tais como: Flask, Jinja 2, Pygments, Sphinx, Werkzeug e outros.

Morando na Austria, trabalhando atualmente na Fireteam, empresa que trabalha em diversos campos na plataforma de jogos.

Uma das coisas que mais perguntam seria qual a diferença entre o Flask e o Bottle, ambos microframeworks web Python, e uma das melhores respostas foi a que ele disse no Stackoverflow:

A grande diferença é que Flask é baseado em outras tecnologias como Werkzeug e Jinja2 que existem há um bom tempo e tentam não reinventar as coisas. Bottle está em outra vertente tentando manter a ideia de manter apenas um arquivo padrão. Eu quero me juntar a eles mas desenvolvedores Bottle não estão muito felizes com a ideia de abandonar a ideologia de um arquivo apenas.

Em relação a flexibilidade: Não há razões para que não seja permitido usar Flask com outras engines de template se isso que precisa. Na verdade, coisas como Flask-Genshi existem: Flask-Genshi e é incrivelmente fácil usar mako com isso, ainda que seja sem a extensão que você quer.

Aviso: Sou o desenvolvedor do Flask, Werkzeug e Jinja2

Tradução livre minha.

 


jinja2

Jinja2 é uma engine de template baseada nos princípios do Django template, porém com mais funcionalidades e mais flexíveis implementações. O Jinja2 é um dos motivos de muitas pessoas gostarem do Flask, permitindo misturar código junto com HTML, tornando as coisas mais simples. Sendo usado em projetos como o Mozilla, Sourceforge, Instagram e outros.

Veja sua simplicidade:

{% extends “layout.html” %}
{% block body %}
<ul>
<ul>{% for user in users %}
<li><a href=”{{ user.url }}”>{{ user.username }}</a></li>
</ul>
</ul>
{% endfor %}

{% endblock %}

{% block title %}{% endblock %}
<ul>
<ul>{% for user in users %}
<li><a href=”{{ user.url }}”>{{ user.username }}</a></li>
</ul>
</ul>
{% endfor %}


werkzeug

Werkzeug é um conjunto de ferramentas para aplicações WSGI. Ele permite as interações entre requisito e resposta de objetos, utilidade de funções e permite criar uma customização de um framework por cima. Trabalhar com ele também é super simples:

from werkzeug.wrappers import Request, Response

@Request.application
def application(request):
return Response('Hello World!')

if __name__ == ‘__main__':
from werkzeug.serving import run_simple
run_simple(‘localhost’, 4000, application)

Exemplo tirado da documentação do Werkzeug


flask

E temos também o Flask, que é baseado no Werkzeug, Jinja2 e boas intenções. Muitas das pessoas que converso que gostam de Python pra desenvolvimento web, dizem que sentem um enorme prazer em desenvolver com Flask, sua flexibilidade e ferramentas poderosas o tornam bem interessante, não é a toa que tenho 2 artigos elogiando o mesmo, um com o Bruno Rocha falando sobre suas aplicações e outro com links de fontes de estudo.

Eu que sou uma pessoa azarada que nunca funciona meus experimentos de primeira, consegui sem pestanejar logo na primeira testar o Flask, seu código é facílimo de aplicar:

from flask import Flask
app = Flask(__name__)

@app.route(“/”)
def hello():
return “Hello World!”

if __name__ == “__main__”:
app.run()

Exemplo tirado da documentação do Flask

Com apenas um arquivo é possível criar um “Hello World”, e podemos subir essa aplicação sem problemas no servidor. E olha que mais bacana ainda, com apenas dois comandos já conseguimos fazer o download e rodar. Claro que antes é necessário que tenha instalado o pip, gerenciador de pacotes do Python.

pip install Flask
python hello.py
* Running on http://localhost:5000/

Exemplo tirado da documentação do Flask

Muito mais do que falar da pessoa, falar do seus projetos nesse ponto acredito ser o mais importante, muito desses projetos dizem muito sobre o Armin, coisas simples, funcionais, extensíveis, coisas que vem do zen do Python, do Tim Peters.

Bonito é melhor que feio.
Explícito é melhor que implícito.
Simples é melhor que complexo.
Complexo é melhor que complicado.
Linear é melhor do que aninhado.
Esparso é melhor que denso.
Legibilidade conta.
Casos especiais não são especiais o bastante para quebrar as regras.
Ainda que praticidade vença a pureza.
Erros nunca devem passar silenciosamente.
A menos que sejam explicitamente silenciados.
Diante da ambigüidade, recuse a tentação de adivinhar.
Deveria haver um — e preferencialmente só um — modo óbvio para fazer algo.
Embora esse modo possa não ser óbvio a princípio a menos que você seja holandês.
Agora é melhor que nunca.
Embora nunca freqüentemente seja melhor que *já*.
Se a implementação é difícil de explicar, é uma má idéia.
Se a implementação é fácil de explicar, pode ser uma boa idéia.
Namespaces são uma grande idéia — vamos ter mais dessas!


 

Deixo também outras fontes de estudos que encontrei esses dias, além dos vídeos e fontes do Armin.


 

http://pythonclub.com.br/what-the-flask-pt-2-flask-patterns-boas-praticas-na-estrutura-de-aplicacoes-flask.html

http://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-i-hello-world


por Eric Hideki em 24 de June de 2014 às 16:19

June 23, 2014

Eric Hideki

blogs_que_me_inspuram_dev_kico

Um mundo a parte de Python, temos o Java, e uma de suas variações que é o Grails, um framework para criação de aplicações web. Acontece que muita gente não conhece e não sabe direito sobre ele, por isso convido o Kico para falar um pouco a respeito e principalmente sobre seus artigos sobre o mercado de desenvolvimento.

Kico, nos fale um pouco sobre você

Minha vida é desenvolvimento de sistemas: minha primeira experiência foi quando tinha uns 6 anos de idade e topei com o BASIC num computador chamado TK-85. Eu digitava os jogos cujo código fonte vinha impresso em livros e revistas, os modificava e me divertia horrores com isto. Passado algum tempo veio o MSX, que também tinha um interpretador BASIC, e de novo a mesma coisa. Não seria exagero dizer que esta experiência foi a origem da minha maior paixão na vida que é a programação/arquitetura/desenvolvimento/o nome que vocês quiserem que envolva criar sistemas. :)

Minha formação acadêmica já é fora dos moldes tradicionais para quem trabalha com desenvolvimento: meu primeiro curso (que quase terminei) foi Filosofia na UFMG. Foi a experiência mais enriquecedora da minha vida, pois foi quando *realmente* aprendi a ler, questionar, entrei em contato com os autores que moldaram minha vida de lá pra cá. O problema é que a paixão sempre foi desenvolvimento e, como todos da minha família trabalham com artes plásticas, me sentia extremamente desconfortável comigo mesmo. Não dava pra fugir: então eu fundei a itexto, que começou como um site de mesmo nome aonde as pessoas postavam seus textos em 1999 e depois passou a lidar apenas com desenvolvimento de sistemas (inicialmente focando no mercado livreiro).

Saindo da Filosofia fui para a Matemática Computacional na mesma universidade, mas acabei terminando o curso como Ciência da Computação aqui na FUMEC. No meio deste caminho acadêmico um monte de coisas ocorreram: tive a oportunidade de trabalhar nas empresas que quis, paralelamente desenvolvi diversos projetos pessoais, comecei a escrever artigos para revistas, publiquei um livro sobre Spring (agora estou terminando um sobre Groovy e Grails), criei e ajudei comunidades de desenvolvimento, dentre as quais a mais ligada ao meu nome é o Grails Brasil, houve também o meu blog, /dev/Kico, que começou como algo simples mas com o passar do tempo veio a crescer ordens de magnitude mais do que eu esperava.

E hoje atuo como consultor, escrevendo mais do que posso, entrando em algumas aventuras e me divertindo muito com tudo isto. :)

blogs_que_me_inspuram_dev_kico

O que é Grails? Quais são suas aplicações? E sua comunidade aqui no Brasil?

Grails é um framework para desenvolvimento web voltado para a plataforma Java EE. É baseado na linguagem Groovy. Já o vi sendo aplicado nas consultorias que dou nas mais variadas situações: desde sistemas para controle de documentos, mineração, telecomunicações, comércio eletrônico, automação, gestão de conteúdo, etc.

Sua comunidade no Brasil é bastante forte: fundei o Grails Brasil em 2008 pois não havia com quem conversar a respeito sobre o assunto. Na primeira semana havia 50 membros cadastrados, a maior parte aqui de Belo Horizonte. De lá pra cá a comunidade não parou de crescer: hoje contamos com quase 2000 membros e possivelmente é o maior grupo de usuários do mundo dedicado ao uso desta tecnologia.

Quais são as principais vantagens que o Java/Grails tem em relação as outras tecnologias?

A principal vantagem do Grails é o fato de ser baseado em Groovy, que é uma linguagem de programação bastante interessante voltada para a JVM. Basicamente tudo o que não gostamos em Java, Groovy resolve para nós. Isto com a vantagem de possuir uma sintaxe próxima da do Java, o que facilita bastante a sua adoção por empresas. Um grande problema que Groovy tinha era a performance, mas com o passar do tempo este problema está sendo superado a cada novo release da linguagem.

Apesar de ser parecida com Java, as diferenças do Groovy em relação ao Java são um excelente atrativo para programadores vindos de outras plataformas. O que ocorre: a plataforma Java EE é excelente, é indiscutível que se trata de uma das melhores plataformas já criadas para o desenvolvimento de aplicações corporativas. O problema é que nem sempre esta é amigável para quem está começando: dado que Groovy é dinâmico e possuí uma sintaxe mais interessante que a do Java em diversos aspectos, os desenvolvedores do Grails tiraram proveito destas características e, com isto, deram uma “cara Groovy” ao Java EE, tornando-o muito mais acessível e produtivo. Na minha opinião Grails acabou com o tédio que era programar na plataforma Java EE (http://www.itexto.net/devkico/?p=224).

Outra vantagem do Grails é que ele não reinventa a roda: é baseado em uma série de tecnologias que sabemos que funcionam bem como, por exemplo, Spring, Hibernate, Sitemesh, toda a API Java EE e muitas outras. Com isto temos uma plataforma de desenvolvimento que, apesar de mostrar uma maneira nova de usar estas APIs, mantém uma base sólida, nos permitindo criar com menos esforço sistemas extremamente escaláveis, estáveis e fáceis de manter.

O que Grails trouxe para o Java EE foi aquilo que víamos no Ruby on Rails: um ambiente de desenvolvimento extremamente produtivo, sem firulas, direto ao ponto e que nos permitia entregar com maior facilidade. Junte tudo isto aos pontos fortes do Java EE (estabilidade, escalabilidade, confiança, riqueza de recursos) e você tem uma ultra plataforma para criação de sistemas web/corporativos/integrações/etc. Aliás, escrevi sobre os ganhos sociais que Groovy e Grails nos trouxeram neste post: http://www.itexto.net/devkico/?p=1632

E o blog Itexto? De onde surgiu a inspiração e a necessidade de compartilhar seus conhecimentos?

Na realidade itexto é o nome da minha empresa: o nome do blog é /dev/Kico. As pessoas costumam confundir o nome por causa do endereço (http://devkico.itexto.com.br ou http://www.itexto.net/devkico). Ele surgiu inicialmente como um bloco de notas no qual escrevia aquelas perguntas que precisava responder com frequencia aos meus colegas de trabalho e clientes, além de também conter algumas das soluções que eu aplicava em mais de um projeto.

Com o passar do tempo acabei escrevendo menos sobre programação e mais sobre coisas que observo no mercado de trabalho (mas já aviso que vêm aí uma longa série de posts técnicos em breve!). Sinceramente não sei o que me leva a escrever: há estes momentos em que sento em frente ao computador e do nada saí um texto baseado em alguma questão que me atormenta naquele momento. Muitas vezes eu sei que estou errado naquilo que estou escrevendo, mas como sei que alguém irá comentar e discordar de mim (prefiro quando discordam), acaba sendo uma oportunidade que aproveito para entender melhor os assuntos sobre os quais trato.

É engraçado que o número de acessos ao blog tem crescido bastante, há inclusive uma versão em inglês dele (http://devkico.itexto.com.br/en) cujos posts tem sido bastante citados em sites como HackerNews, The Server Side, DZone e muitos outros. No entanto meu foco é Brasil: quando escrevo algo na versão em inglês é mais para obter um feedback de pessoas que moram fora do país.

Uma grande motivação para escrever é a percepção que tenho de que a maior parte dos desenvolvedores se foca tanto no técnico e dão tanta atenção ao imediato, ao hype (http://www.itexto.net/devkico/?p=1148) que se esquecem de fazer as perguntas fundamentais: por que isto é interessante? O que é isto? Qual o valor deste negócio? Gosto de cutucar estes pontos, e se puder no processo desmascarar visões que naquele momento (posso estar errado) se mostram completamente equivocadas (ou mesmo mal intencionadas), ponto pra mim.

Outro dia vi um tweet do Tiago Peczenyj sobre mim que confesso me deixou extremamente feliz: “eu sempre imagino o @loboweissmann com as mãos doendo, sangrando de tanto dar porrada nas nossas falsas ideias”.

Esta e a maior motivação. :)

Um dos artigos que gostei muito foi sobre o programador invisível, no qual você comenta sobre as tecnologias que são subjugadas pela grande maioria, tais como Cobol por exemplo?

A questão é: qual maioria? Se uso a palavra maioria, o faço dentro de um contexto. Se o contexto for as pessoas que vemos nas redes sociais falando sobre desenvolvimento e eventos relacionados, é uma coisa: outra totalmente diferente é o contexto no qual pego TODOS os desenvolvedores.

Dentro deste contexto, que é o que falo no post, esta “maioria” se mostra minoria. Este é o grande ponto na minha opinião: e o grande problema que vejo é o fato de que, ao nos focarmos no que esta real minoria fala, acabamos por reinventar a roda repetidas vezes, ignoramos um conhecimento enorme que o pessoal adquiriu no decorrer do tempo, e terminamos chamando de novidade o que pra maioria é cotídiano por décadas.

Este foi um post pra acordar o pessoal: muitas vezes nós acreditamos que o sujeito que tá nos mostrando a novidade da vez sabe de tudo e está nos vendendo algo realmente novo quando, na realidade estamos nos deparando com a mesma coisa de novo. A intenção deste post era mostrar o óbvio: o rei estava nu.

Na sua visão, como está o mercado de desenvolvimento web hoje? Isso em relação a qualidade das aplicações que estão sendo feitas e os salários dos desenvolvedores.

Um grande problema na minha opinião é o hype envolvendo novas tecnologias que, muitas vezes, nos faz esquecer de fazer questionamentos básicos. Vou dar um exemplo recente: Node.js. Inicialmente a idéia é bacana: Javascript do lado servidor. Legal: vou usar a mesma linguagem tanto no front quanto no backend. Mas não vejo muitos fazerem as perguntas importantes: será que meu desenvolvedor de frontend está capacitado para lidar com o backend? Será que ver meu mundo como um prego e minha única ferramenta o martelo uma boa opção? Será que aquilo que já sabemos há tempos, de que devemos usar a ferramenta certa pra situação certa caiu em desuso?

(não estou dizendo que Node.js seja ruim: apenas me preocupo com a ausência destes questionamentos)

As pessoas não se questionam: elas usam e pronto. Vou dar outro exemplo: em uma palestra que fui sobre Scala fiz o seguinte questionamento ao palestrante: “por que minha equipe que já está acostumada com Java deve adotar esta linguagem?”. Resposta que obtive: 30 segundos de constrangedor silêncio.

As perguntas fundamentais não são feitas. Este é o maior problema que vejo. Se você não as faz, surgem idéias como a de que você deve pagar o menor salário possível pois todo programador é igual, que você sempre deve pegar a tecnologia que acabou de sair por que é a melhor, este tipo de coisa.

Com relação aos salários: óbviamente a idéia por trás da empresa é maximizar seus lucros, sendo assim é natural que haja a tentativa de se minimizar os custos. Uma das formas é reduzindo o salário do desenvolvedor. Isto é uma boa? Não estaríamos desmotivando boas cabeças a entrarem na área? É muito raro eu presenciar por parte dos empresários um questionamento mais profundo a respeito destas questões. Normlamente o foco é baixar o salário pra maximizar o lucro. E depois não entendem por que o projeto atrasa, por que há tantos bugs, etc.

E há outro problema que ainda é tabu no Brasil e que me assusta bastante: as más condições de trabalho e a ocorrência frequente do fenômeno do assédio moral. No Brasil sou uma das únicas pessoas que escreveu publicamente sobre isto (http://www.itexto.net/devkico/?cat=63). O assunto ainda é um tabu. Quando tornei público meu TCC sobre o assunto (http://www.itexto.net/devkico/?p=1385) me foi dito que eu jamais conseguiria outro emprego. Acredito que isto ilustre bem a situação.

Agora, sinceramente? Acredito que o salário quem faz não é o mercado, mas o indivíduo. Se você se esforça, corre atrás de verdade, é honesto e sabe o que está fazendo uma hora ou outra dá certo.

E o que você acha sobre Python?

Meu conhecimento de Python é bastante limitado. Eu a uso no trabalho atual para escrever simuladores de alguns equipamentos com os quais preciso interagir e no passado usei o Jython no WebLogic. Tirando isto, brinquei um pouco com um framework chamado Flask, que achei MUITO interessante, mas apenas isto.

Me pareceu um ambiente de desenvolvimento bem interessante, mas nunca usei com grande intensidade pra poder falar com segurança.

Para finalizar gostaria que você comentasse de um post seu falando sobre piratear livros e materiais de desenvolvimento. Por que há ainda essa prática que é tão prejudicial para o crescimento de materiais de qualidade no mercado?

Por que é fácil e o pirata não tem consciência do trabalho que dá gerar este material.
Por que não há respeito algum pelo autor.
Por que não há visão de médio e longo prazo: pagar pelo material é investir. Você está fornecendo ao autor meios para que melhore aquele trabalho.

Aliás, é engraçado: as pessoas dizem com facilidade que algo é caro, mas com dificuldade extrema justificam esta afirmação, já reparou isto? Já tive um diálogo assim uma vez:
Seu livro de Spring que custa R$ 29,90 é caro.
Mesmo, por que?
Por que sim.

Quem pirateia simplesmente não sabe o que significa a palavra valor. Esta é a verdade.


por Eric Hideki em 23 de June de 2014 às 12:12

June 19, 2014

Filipe Saraiva

KDE passando o chapéu para realização do Randa Meeting 2014

Desde 2009 o KDE reúne durante alguns dias diversos desenvolvedores na cidade suíça de Randa para trabalharem em projetos chave da comunidade. Esses sprints já resultaram em importantes avanços para os usuários das tecnologias desenvolvidas pelo KDE, como o KDE Frameworks 5, o Plasma Next, melhorias no Qt, diversos softwares do KDE Edu, e mais.

Em 2014 haverá uma nova edição desse encontro, o Randa Meeting 2014, e a comunidade iniciou uma campanha de arrecadação para custear essa atividade.

Visite a página da campanha ou a versão que o KDE Brasil traduziu e saiba mais sobre os projetos desenvolvidos nas edições anteriores, quais os planos para a edição de 2014, quem deverá participar, quais os tipos de despesas, e mais.

Eu já fiz minha contribuição, agora é com você – seja usuário, desenvolvedor, ou simpatizante do KDE ou das comunidades e ideias do software livre em geral, contribua! Toda ajuda é bem-vinda.

por Filipe Saraiva em 19 de June de 2014 às 15:26

Bruno Cezar Rocha

Watching a directory for file changes with Python

requirement

Watch changes in a ftp folder, whenever a new xml file is created, or when an existing file is modified this needs to be parsed and its contents inserted in the database.

tools

  • Python 2..7
  • watchdog

Install from pip

pip install watchdog

Watchdog is a Python API library and shell utilities to monitor file system events.

How to

First create the monitoring script, it will run daemonized and will observe any changes to the given directory. In that script 3 modules/classes will be used

  • time from Python will be used to sleep the main loop
  • watchdog.observers.Observer is the class that will watch for any change, and then dispatch the event to specified the handler.
  • watchdog.events.PatterMatchingHandler is the class that will take the event dispatched by the observer and perform some action

watchforchanges.py

import time  
from watchdog.observers import Observer  
from watchdog.events import PatternMatchingEventHandler  

PatternMatchingEventHandler inherits from FileSystemEventHandler and exposes some usefull methods:

Events are: modified, created, deleted, moved

  • onanyevent: if defined, will be executed for any event
  • on_created: Executed when a file or a directory is created
  • on_modified: Executed when a file is modified or a directory renamed
  • on_moved: Executed when a file or directory is moved
  • on_deleted: Executed when a file or directory is deleted.

Each one of those methods receives the event object as first parameter, and the event object has 3 attributes.

  • event_type
    'modified' | 'created' | 'moved' | 'deleted'
  • is_directory
    True | False
  • src_path
    path/to/observed/file

So to create a handler just inherit from one of the existing handlers, for this example PatternMatchingEventHandler will be used to match only xml files.

To simplify I will enclose the file processor in just one method, and I will implement method only for onmodified and oncreated, which means that my handler will ignore any other events.

Also defining the patterns attribute to watch only for files with xml or lxml extensions.

 class MyHandler(PatternMatchingEventHandler):
    patterns = ["*.xml", "*.lxml"]

    def process(self, event):
        """
        event.event_type 
            'modified' | 'created' | 'moved' | 'deleted'
        event.is_directory
            True | False
        event.src_path
            path/to/observed/file
        """
        # the file will be processed there
        print event.src_path, event.event_type  # print now only for degug

    def on_modified(self, event):
        self.process(event)

    def on_created(self, event):
        self.process(event)

With the above handler only creation and modification will be watched now the Obserser needs to be scheduled.

if __name__ == '__main__':
    args = sys.argv[1:]
    observer = Observer()
    observer.schedule(MyHandler(), path=args[0] if args else '.')
    observer.start()

    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()

    observer.join()

You can set the named-argument "recursive" to True for observer.schedule. if you want to watch for files in subfolders.

That's all needed to watch for modifications on the given directory, it will take the current directory as default or the path given as first parameter.

python watch_for_changes.py /path/to/directory

let it run in a shell and open another one or the file browser to change or create new .xml files in the /path/to/directory.

echo "testing" > /tmp/test.xml 

Since the handler is printing the results, the outrput should be:

rochacbruno@~/$ python watch_for_changes.py /tmp
/tmp/test.xml created
/tmp/test.xml modified

Now to complete the script only need to implement in the process method, the necessary logic to parse and insert to database.

For example, if the xml file contains some data about current track on a web radio:

<?xml version="1.0" encoding="ISO-8859-1" standalone="yes" ?> 
 <Pulsar>
  <OnAir>
     <media_type>default</media_type> 
     <media>
        <title1>JOVEM PAN FM</title1> 
        <title2>100,9MHz</title2> 
        <title3>A maior rede de radio do Brasil</title3> 
        <title4>00:00:00</title4> 
        <media_id1>#ID_Title#</media_id1> 
        <media_id2>#ID_SubTitle#</media_id2> 
        <media_id3>#ID_Album#</media_id3> 
        <hour>2013-12-07 11:44:32</hour> 
        <length>#Duration#</length> 
        <ISRC>#Code#</ISRC> 
    <id_singer>#ID_Singer#</id_singer>
    <id_song>#ID_Song#</id_song>
    <id_album>#ID_Album#</id_album>
    <id_jpg>#Jpg#</id_jpg>
     </media>
  </OnAir>
</Pulsar>

The easiest way to parse this small xml is using xmltodict library.

pip install xmltodict

With xmltodict.parse function the above xml will be outputed as an OrderedDict

OrderedDict([(u'Pulsar',
    OrderedDict([(u'OnAir',
        OrderedDict([(u'media_type', u'default'),
        (u'media', 
            OrderedDict([(u'title1', u'JOVEM PAN FM'),
                         (u'title2', u'100,9MHz'),
                         (u'title3', u'A maior rede de radio do Brasil'),
                         (u'title4', u'00:00:00'),
                         (u'media_id1', u'#ID_Title#'),
                         (u'media_id2', u'#ID_SubTitle#'),
                         (u'media_id3', u'#ID_Album#'),
                         (u'hour', u'2013-12-07 11:44:32'),
                         (u'length', u'#Duration#'),
                         (u'ISRC', u'#Code#'),
                         (u'id_singer', u'#ID_Singer#'),
                         (u'id_song', u'#ID_Song#'),
                         (u'id_album', u'#ID_Album#'),
                         (u'id_jpg', u'#Jpg#')]))]))]))])

Now we can just access that dict to create the registry on filesystem or something else. Notice that I will use a lot of get method of dict type to avoid KeyErrors.

with open(event.src_path, 'r') as xml_source:
    xml_string = xml_source.read()
    parsed = xmltodict.parse(xml_string)
    element = parsed.get('Pulsar', {}).get('OnAir', {}).get('media')
    if not element:
        return
    print dict(element)

ant the output will be:

{u'hour': u'2013-12-07 11:44:32',
 u'title2': u'100,9MHz',
 u'id_album': u'#ID_Album#',
 u'title1': u'JOVEM PAN FM',
 u'length': u'#Duration#',
 u'title3': u'A maior rede de radio do Brasil',
 u'title4': u'00:00:00',
 u'ISRC': u'#Code#',
 u'id_song': u'#ID_Song#',
 u'media_id2': u'#ID_SubTitle#',
 u'media_id1': u'#ID_Title#',
 u'id_jpg': u'#Jpg#',
 u'media_id3': u'#ID_Album#',
 u'id_singer': u'#ID_Singer#'}

Much better than XPATH, and for this particular case when the xml_source is small there will no relevant performace issue.

Now only need to get the values and populate the database, in my case I will use Redis DataModel as storage.

also I will use magicdate module to automagically convert the date format to datetime object.

import sys
import time
import xmltodict
import magicdate
from watchdog.observers import Observer
from watchdog.events import PatternMatchingEventHandler

from .models import Media


class MyHandler(PatternMatchingEventHandler):
    patterns=["*.xml"]

    def process(self, event):
        """
        event.event_type
            'modified' | 'created' | 'moved' | 'deleted'
        event.is_directory
            True | False
        event.src_path
            path/to/observed/file
        """

        with open(event.src_path, 'r') as xml_source:
            xml_string = xml_source.read()
            parsed = xmltodict.parse(xml_string)
            element = parsed.get('Pulsar', {}).get('OnAir', {}).get('media')
            if not element:
                return

            media = Media(
                title=element.get('title1'),
                description=element.get('title3'),
                media_id=element.get('media_id1'),
                hour=magicdate(element.get('hour')),
                length=element.get('title4')
            )
            media.save()

    def on_modified(self, event):
        self.process(event)

    def on_created(self, event):
        self.process(event)


if __name__ == '__main__':
    args = sys.argv[1:]
    observer = Observer()
    observer.schedule(MyHandler(), path=args[0] if args else '.')
    observer.start()

    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()

    observer.join()

That is my usecase, but the example can be used for any kind of requirement.

Another useful module is Workflow by Massimo Di Pierro that creates workflows based on rules defined in a config file.

por Bruno Rocha em 19 de June de 2014 às 03:13

June 18, 2014

Henrique Bastos

Hello world!

Welcome to WordPress. This is your first post. Edit or delete it, then start blogging!

por henrique em 18 de June de 2014 às 01:56

June 17, 2014

Eric Hideki

Google_app_engine

Hoje converso com o Valdir Stumm Júnior, responsável pelo blog Python Help, blog repleto de tutoriais de alta qualidade sobre Python, abordando assuntos como as características e mágicas da linguagem, além de como trabalhar com web com o Google App Engine.

Valdir, fale um pouco de ti.

Sou professor da área de programação no Instituto Federal Catarinense, em Blumenau. Conheci Python em 2005 em um projeto de uma disciplina na graduação, mas comecei a utilizar de forma mais intensiva em 2007, quando fui desenvolver o meu trabalho de graduação, que se tratava de uma extensão para o Plone. Depois disso, também utilizei Python no mestrado. Daí para diante, passei a usar Python em sala de aula e no desenvolvimento de projetos.

Qual foi a inspiração para criar o blog?

Criei o blog porque eu percebi que era preciso criar um mecanismo para que os meus alunos pudessem aprender conceitos além daqueles vistos em sala de aula, cujo tempo era restrito. Além de poder publicar artigos relacionados às dúvidas que surgiam em sala e fora dela, o blog também tornou possível a publicação de materiais envolvendo novos conceitos e tecnologias, para que os alunos pudessem avançar além daquilo que foi visto na disciplina.

De onde são feitos os estudos para criar seus artigos?

Em geral, os textos surgem de dúvidas ou coisas interessantes que encontro quando estou escrevendo código Python. As fontes de consulta que mais uso para resolver minhas dúvidas são: a documentação oficial, respostas do StackOverflow.com, e os livros Learning Python e Python in a Nutshell.

E quais são suas inspirações para poder compartilhar seus conhecimentos sobre Python?

Uma das coisas que mais gosto de fazer é escrever. No meu dia a dia, fico sempre em alerta sobre algo que poderia render um post no blog. Às vezes, a ideia vem de um módulo que acabei de aprender a utilizar. Nesse caso, escrever um texto me ajuda a firmar o que aprendi, e também a estudar o assunto com mais atenção. Em outros casos, a ideia surge ao revisitar determinado problema. Tendo aprendido outras linguagens antes, dá para perceber que o modo de pensar muda depois de começar a programar em Python. Assim, percebo que algumas coisas simples em Python podem não ser tão triviais para quem está começando com a linguagem, mesmo que já tenha experiência com programação em outras linguagens. E é sobre esse tipo de coisa que gosto de escrever.

Por que Python?

Porque é simples o suficiente para que o iniciante não se confunda e para que o experiente não se entedie. Porque é consistente, característica que é primordial para que o iniciante consiga absorver bem os conceitos. Porque tem uma stdlib gigantesca, que é complementada pela enorme quantidade de bibliotecas e frameworks que a comunidade fornece. Porque tem um REPL, que permite ao iniciante experimentar a linguagem e aprender de forma interativa. Porque tem uma comunidade engajada, com material novo surgindo a cada dia, com diversas fontes para busca de ajuda. E também porque tem o IPython, o IPython Notebook e o Dreampie que quebram um galhão no dia a dia de quem está desenvolvendo.

O que acha de programar com o Google App Engine?

Google_app_enginehttp://pythonhelp.wordpress.com/2013/10/03/um-blog-com-google-app-engine/

Eu acho muito legal esse negócio de programar para a web sem se preocupar muito com a infraestrutura que vai dar suporte. O App Engine é perfeito para quem está começando, pois permite desenvolver e já publicar o app de uma forma muito simples, bastando ter uma conta Google. Com ele, podemos deixar para lá aquela chatice de instalar e configurar um servidor especialmente para publicar um aplicativo.

Uma das coisas que sempre quis fazer e você já tem feito é abordar diversas features da linguagem, seja as bibliotecas embutidas como datetime, e além de outros externos, criando tutoriais e dicas a respeito. Quais são as principais vantagens para quem não conhece?

A biblioteca padrão do Python é repleta de ferramentas úteis. O pessoal costuma dizer que Python “vem com as pilhas inclusas”, isto é, tudo o que você precisar para resolver o seu problema já está incluso quando você instala o interpretador. Então, conhecer bem a biblioteca padrão significa ter um caixa de ferramentas muito maior na hora de resolver um problema. Porém, não é só na stdlib que tem ferramentas boas. Pelo contrário, existe uma enorme quantidade de bibliotecas de terceiros que são, às vezes, até melhores que as disponíveis na biblioteca padrão. Acho que o melhor exemplo disso é a requests (http://docs.python-requests.org/en/latest/), que é uma lib para trabalhar com HTTP que é, na minha opinião, muito melhor do que a correspondente na stdlib, a urllib2.

O que o blog te trouxe de interessante?

O blog me estimulou a estudar mais a fundo vários assuntos. Afinal, antes de escrever um artigo sobre um tema qualquer, é imprescindível dar uma boa estudada nele, para não cometer gafes. Além da parte técnica, acho que treinar a escrita e a comunicação com outras pessoas é muito importante. Como professor, é essencial que eu consiga me expressar da forma mais clara possível, e acho que escrever me ajuda a melhorar não somente a escrita, mas também o discurso.

Deixe suas considerações sobre dicas para quem deseja aprender Python?

Acho que a principal dica é: organize seus estudos. Existem muitos materiais de excelente qualidade na web, mas é fácil se perder nessa imensidão de conteúdo. Para quem está começando a programar, sugiro que estude através de cursos online, como por exemplo o Python para Zumbis, pois eles já são cuidadosamente planejados para que o iniciante veja os assuntos de forma gradual, fazendo atividades práticas com feedback imediato, firmando o conteúdo que foi recém visto. Entretanto, a melhor forma de aprender Python é programando muito. Pratique; fazendo projetinhos para resolver problemas do seu dia a dia (mesmo que já existam programas com a mesma finalidade) e resolvendo problemas que exercitem a sua lógica de programação. Existem vários recursos que podem servir como guias nesse processo, como os sites codingbat.com e projecteuler.net. Outro recurso bem interessante, que conheci há pouco, é o projeto Python Koans (github.com/gregmalcolm/python_koans) que é um tutorial interativo em que o sujeito aprende com uma abordagem incremental baseada em testes. Enfim, recursos existem aos montes, basta escolher algum e praticar muito.


por Eric Hideki em 17 de June de 2014 às 15:32

June 16, 2014

Magnun Leno

Registradores no VIM

Esses dias surgiu uma pergunta do Arthur na lista de discussão de usuários de VIM do Brasil sobre "realizar deleções sem sobrescrever o texto já copiado". Parece uma coisa boba para quem vem de outros editores, mas tudo no VIM é extremamente profundo, se você se dedicar a explorar uma pequena funcionalidade você pode perder o dia todo e não ter lido/entendido tudo sobre o assunto.

VIM Rocks

"E por quê perder tanto tempo entendendo uma funcionalidade do VIM pode ser útil? Não basta apenas saber o básico e seguir adiante?" Não, não basta. Simplesmente porque o VIM é como um monstro de LEGO e se você entender melhor uma pequena peça, você vai ver que pode usar essa peça combinada com centenas de outras, e assim ter um fluxo de trabalho extremamente otimizado.

Registradores no VIM é um artigo original de Mind Bending

por Magnun em 16 de June de 2014 às 19:30

Eric Hideki

Python_Cookbook_resenha

Uma das maiores vantagens da linguagem são as suas bibliotecas embutidas, as famosas ‘baterias inclusas’, no qual oferecem diversas facilidades ao resolver problemas diários enquanto desenvolvemos uma aplicação. E o Python Cookbook veio com uma injeção enorme de diversas bibliotecas que a grande maioria não conhece. Desde o iniciante que está programando a pouco tempo com Python, ou veio de outra linguagem, até o mais experiente programador o livro é indicado.

Python_Cookbook_resenha

Python Cookbook veio com diversos intuitos na verdade, seja para apresentar as novidades que a versão 3 do Python vem agregar, demonstrar como desenvolver soluções pythonicas e elegantes, prover discussões sobre os motivos de escolher essa ou aquela forma de desenvolvimento, levar em consideração o desempenho e processamento que seu código pode ter se escolher a forma errada, e principalmente lhe poupar diversas dores de cabeça.

A comunidade Python esses dias andaram em diversas discussões sobre o futuro da linguagem. Atualmente temos 2 versões disponíveis: 2.x e 3.x. A grande maioria dos projetos atuais se encontram na versão 2.x, sendo a versão preferencial para criação de projetos em produção. Mas por que isso? Por que ainda permanecemos na versão 2.x se já existe uma versão nova e melhorada?

O grande problema que as pessoas enfrentam é no quesito das bibliotecas externas. Até algum tempo atrás grande parte delas não havia sido portada para a nova versão, e sinceramente ainda uma boa parte não foram portadas. E esse processo leva-se um tempo para arrumar, até porque muitas delas são bastante complexas.

E para que não tenha esses tipos de dores de cabeça, muitos dos programadores ainda não migraram para a 3.x. O framework Django tem suporte a versão 3.x, um dos frameworks senão o framework mais utilizado para criação de projetos web, porém ainda encontra algumas incompatibilidades. Mas a cada dia esse cenário está mudando.

Python 3.x vem com diversas melhorias em relação a performance, tratamento de unicodes, sintaxe mais simplificada e diversas outras. Sinceramente em apenas 2 horas de estudos é possível já criar projetos de pequeno/médio porte sem problemas, e IMO, SIM, todos devemos o mais breve possível nos atualizarmos e migrarmos a nova versão.

E com tudo isso dito, o que tem a ver com o livro? Python Cookbook é a porta de entrada para o ingresso nessas novas funcionalidades que a versão traz. Tratando de temas cotidianos como tratamento de strings e integers, arquivos, metaprogramaçao, concorrência, classes e objetos, processamento de dados e outros, e mostrar que é possível utilizar a nova versão sem grandes problemas.

Quem nunca se deparou com alguns desses problemas e levou certo tempo para descobrir como solucionar?

- Manter dicionários em ordem;
– Agrupar registros de acordo com um campo;
– Pesquisar e substituir textos;
– Remover caracteres indesejados de strings;
– Iterar ao contrário;
– Ler e escrever dados CSV;
– Ler e escrever dados JSON;
– Diversos outros.

Mas a questão não é apenas mostrar como resolver isto, é fazer de forma simples, concisa, performática e pythonica.

Este não é um livro para se ler do começo ao fim, é um livro de receitas, que a cada problema que surgir ir fazer uma consulta. Só não digo que é aquele tipo de livro de carregar no bolso porque ele é grande. Mas isso não é algo ruim, muito pelo contrário, a quantidade de informações são indispensáveis.

Uma das coisas mais bacanas é que cada tópico é recheado de exemplos práticos, aqueles que podemos utilizar sem problemas, é tudo sem enrolação. E melhor ainda, em cada um é explicado detalhadamente o porquê de tal escolha ser a mais indicada. Não é algo que a pessoa diz que é o certo e pronto, há em cada um uma seção de discussão. Isso é realmente importante e enriquece muito o conteúdo.

A tradução ficou ótima, respeitando os termos da linguagem, não inventando ou com rodeios. Infelizmente vemos muitos problemas nesse quesito principalmente com livros de tecnologia.

O bacana de tudo é que por tratar de diversos tópicos desde os básicos aos mais avançados, o público alvo do livro atinge praticamente qualquer pessoa que deseja se aprofundar mais sobre o que a linguagem tem a oferecer. Claro que se a pessoa não tem qualquer tipo de conhecimento de programação não irá usufruir, mas tendo o mínimo de conhecimento e já esteja trabalhando em algum projeto, com certeza o livro é um MUST HAVE.

Python se destaca principalmente em sua atuação na web, seja em empresas grandes como Google, Youtube, Disqus, Instagram e outros, mas o que enriquece ainda mais a tecnologia é a sua diversidade. Utilizamos bastante Python para processamento de dados, tratamento de imagens, aplicações desktop, criação de jogos, aplicações mobile, e muito forte em computação científica. Isso é fantástico pois sabendo o mínimo da linguagem você pode ter diversos campos de atuação, você não fica preso a um determinado campo. E principalmente, sabendo apenas Python você consegue abranger a todos, não é necessário um treinamento intensivo para criar e desenvolver.

E isso é uma das maravilhas da linguagem, além do suporte da comunidade e diversos cursos, livros e tutoriais disponíveis tanto em livros como na internet. Livros como o Python Cookbook vem para enriquecer ainda mais seus conhecimentos, sendo muito importante para aprender a desenvolver de forma certa e principalmente para que não haja problemas de performance. Com a velocidade e o crescimento das aplicações, uma hora ou outra nos deparamos com esses problemas, poupando o trabalho de refatoração de código já fazendo a coisa certa desde o começo.

Nos primeiros capítulos começamos com coisas básicas como estruturas de dados e algoritmos, strings e textos, e tratamento de números datas e horas. Apenas nesses 3 tópicos já são mostrados como importar bibliotecas certas para cada tipo de necessidade. Muitos programadores tem a ideia de que uma biblioteca tem diversas funções, isso é verdade em certo ponto, mas o que não sabem é que existem diversas variações, aplicações e resultados que cada uma apresenta.

Depois nos aprofundamos um pouco mais na questão de iteradores e geradores, arquivos e I/O, nesses capítulos são interessantes os detalhes dados no tratamento de unicodes por exemplo, como trabalhar facilmente com a manipulação de iteradores, seja na verificação de aquivos, lista de diretórios, criar arquivos e diretórios temporários e outros.

Temos também Codificação e processamento de dados, fundamentais quando trabalhamos com bancos de dados grandes. Funções, Classes e objetos, como definir funções com argumentos default ou senão funções de callback inline.

Ainda existem diversos outros tópicos importantes que contém o livro que vale a pena dar uma olhada. Fica a dica então de darem uma olhada e ver realmente quão poderosa a linguagem é e as facilidades que ela oferece.

Para mais informações, acesse – http://www.novateceditora.com.br/livros/python-cookbook/

Se deseja ver os capítulos que o livro aborda, acesse o sumário – http://www.novateceditora.com.br/livros/python-cookbook/sumario9788575223321.pdf

E também alguns dos exemplos que falei, a Novatec disponibiliza o primeiro capítulo gratuitamente para analisar a qualidade do material – http://www.novateceditora.com.br/livros/python-cookbook/capitulo9788575223321.pdf


por Eric Hideki em 16 de June de 2014 às 12:20

June 13, 2014

Magnun Leno

Hack ‘n’ Cast v0.2 - HTML & CSS

O HTML é co-responsável pela grande revolução que foi a internet. Junte-se a trupe do Hack 'n' Cast e descubra se isso é uma tecnologia, doença ou solução. E saiba porquê você deve usar um guarda-chuva ao escrever CSS.

Baixe o episódio e leia o shownotes

por Magnun em 13 de June de 2014 às 07:59

June 11, 2014

Eric Hideki

flask

flask

Um dos frameworks que anda surpreendendo as pessoas é o Flask, um micro-framework Python que é muito fácil de se aprender, extensões que resolvem a grande maioria das necessidades ao criar suas aplicações, excelente sua documentação e comunidade.

Juntando o útil ao agradável, deixo alguns links caso haja interesse e outros links para quando se cansar de ler sobre Flask.

Como começar a aprender a programar com Flask

O Bruno Rocha fez um artigo fantástico para o Pythonclub falando sobre como começar um projeto Flask de forma certa, com excelentes dicas e ótima didática. IMPERDÍVEL!

 Preparando o ambiente de desenvolvimento com Flask

RealPython é um excelente blog que explica passo – a – passo como começar a preparar seu ambiente de desenvolvimento, a forma de organizar os arquivos e fazer deploy.

Bônus: No blog já tem a segunda parte do tutorial ensinando a criar uma página de login, não perca.

Criando um tomador de notas em Flask

Já pensou que poderíamos criar uma aplicação personalizada para anotarmos as coisas importantes do dia a dia? Veja então como criar dinamicamente um tomador de notas.

Create a dynamic webpage with Twitter and Flask’s rendering engine, Jinja2

Aprendendo e Ensinando Python

Como colaborar na tradução do Djangobook sem conhecer programação

Diferenças entre Flask e Pyramid

Criando desenhos com Python

Por que usar Python para ensino de programação?

Bônus do bônus:  Livro gratuito de boas práticas e patterns para projetos Flask.

 


por Eric Hideki em 11 de June de 2014 às 00:03

June 07, 2014

Allison Azevedo

Allisson

Acabei de postar a versão 1.0.0 da biblioteca django-pagseguro2, que tem como meta promover o uso da API PagSeguro V2 com o Django.

Links:


por Allisson Azevedo em 07 de June de 2014 às 19:29

June 05, 2014

Magnun Leno

Programando Java sem IDE

Há algum tempo eu concluí minha Pós-Graduação (ainda estou devendo um texto sobre isso aqui) e, devido a "regras institucionais", fui "instigado" (*cof*obrigado*cof*) a usar Java. Sendo eu um usuário de VIM, uma das coisas que mais me irrita ao programar em Java é essa amarração de IDE. Então resolvi fazer algo que poucos programadores Java sabem, programar sem IDE.

Java na mão!

Escrevendo Java na mão!!

Sim, eu sou cabeça dura a esse ponto. Meu fluxo de trabalho no VIM já é muito bem estabelecido, e me adaptar a uma nova ferramenta com inúmeras limitações (quando comparado à edição no VIM) não é nada agradável.

Programando Java sem IDE é um artigo original de Mind Bending

por Magnun em 05 de June de 2014 às 17:23

June 04, 2014

Thiago Avelino

Swift Language (Apple) first steps

Apple launched the Swift language (Looking for the Swift parallel scripting language? Please visit swift-lang.org) at WWDC 2014. A modern language to program for Mac and iOS!

Strongly typed language, where you explicitly what type (variable, arguments, and function returns), syntax reminds dynamic languages with Python, Go, Ruby and JavaScript.

Apple offers a free comprehensive guide on language in HTML and iBook formats.

  • We can put zero left freely to improve readability, insert _ to separate groups of numbers and add the + in front. That server to improve readability of the program (does not alter the value of the number):
let a = 1000000
let b = 0.0000001

// readable
let a = 1_000_000
let b = 0.000_000_1
  • Practical numerical ranges: 0..5 and 0...5 (Ruby)

  • Unicode variables:

let π = 3.1415926
  • Tween strings (expand variables and expressions inside strings):
var name = "Thiago Avelino"
var yaer = 25
println "Hi, my name \(name), 'm \(year) years."
  • Few functions/methods native to strings works:

    • hasPrefix
    • hasSuffix
    • uppercaseString
    • lowercaseString
    • countElements
    • isEmpty
  • Not have regular expressions

  • Ternary operators: (condition ? yes : no)

I liked the language, as 'm used to not bother me Go explicit types, lack of regular expression can be a problem seems, but it is a pleasant language to learn!

por avelino em 04 de June de 2014 às 04:20

June 02, 2014

Bruno Cezar Rocha

What The Flask - Série de 6 artigos + tutorial para aprender desenvolvimento web com Python e Flask

What The Flask

6 passos para ser um Flask ninja!

Olá, nesta semana comecei a publicar a série What The Flask lá no PythonClub.

http://res.cloudinary.com/diu8g9l0s/image/upload/v1400201393/pythonclub/logo_275x130.png

para quem ainda não conhece, o PythonClub é um blog colaborativo feito pela comunidade e hospedado no github. Colabore você também!

Nesta série de 6 artigos/tutoriais pretendo abordar de maneira bem detalhada o desenvolvimento web com o framework Flask.

Depois de mais de um ano desenvolvendo projetos profissionais com o Flask e adquirindo experiência também no desenvolvimento do projeto open source Quokka CMS resolvi compartilhar algumas dicas para facilitar a vida de quem pretende começar a desenvolver para web com Python.

A série What The Flask será dividida nos seguintes capítulos.

  1. Hello Flask: Introdução ao desenvolvimento web com Flask
  2. Flask patterns: boas práticas na estrutura de aplicações Flask
  3. Plug & Use: extensões essenciais para iniciar seu projeto
  4. DRY: Criando aplicativos reusáveis com Blueprints
  5. from flask.ext import magic: Criando extensões para o Flask e para o Jinja2
  6. Run Flask Run: "deploiando" seu app nos principais web servers e na nuvem.

Hello Flask

Parte 1 - Introdução ao desenvolvimento web com Flask

Conhecendo o Flask

Quick and Dirty Tutorial: Desenvolvendo um aplicativo de notícias

Para acompanhar a série completa acesse o PythonClub

Comentários, dúvidas, sugestões e formulário a respeito do curso online e do livro de Flask também estão no lá no final do artigo no PythonClub. :)

por Bruno Rocha em 02 de June de 2014 às 14:30