Planeta PythonBrasil

PythonBrasil[9]

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 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 = fx 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

June 01, 2014

Filipe Saraiva

Complementação de código no editor de scripts do Cantor

Alguns meses atrás escrevi sobre as novas funcionalidades disponíveis no Cantor a partir do lançamento do KDE 4.13. Entretanto, eu acabei não escrevendo sobre uma nova e bastante útil funcionalidade também disponível naquele lançamento – a nova complementação de código disponível no editor de scripts do Cantor.

Eu havia desenvolvido o destaque de sintaxe padrão para cada backend que suporta o editor de scripts. Esse editor é baseado em KatePart/KTextEditor, uma impressionante biblioteca da KDE libs utilizada em vários softwares do KDE, como o KWrite, Kate, Kile, KDevelop, e mais.

Os desenvolvedores do Kate lançaram uma nova funcionalidade no KDE 4.13, uma versão melhorada da complementação de código para todas as linguagens suportadas pelo KTextEditor. Essa funcionalidade utiliza os mesmos arquivos XML usados no destaque de sintaxe de cada linguagem para disponibilizar a nova complementação de código.

Como eu desenvolvi o destaque de sintaxe padrão para o editor de scripts, essa nova complementação de código foi habilitada por padrão também. Fantástico!

Então, vamos ver algumas imagens dessa nova funcionalidade em ação:

code-completion-scilab-cantor

Complementação de código para Scilab

Na figura acima a complementação de código foi utilizada para escrever um comando plot no editor de scripts para a interface com o Scilab.

code-completion-maxima-cantor

Complementação de código para Maxima

No backend do Maxima backend podemos ver a complementação de código funcionando não apenas com os comandos que iniciam com o fragmento de texto digitado: por exemplo, contour_plot apareceu na lista de sugestões.

Esta nova complementação de código está disponível para todos os backends que implementam o suporte ao editor de scripts. Para utilizá-la basta digitar Ctrl+Espaço no editor.

Existem algumas melhorias para esta funcionalidade a serem implementadas no futuro. Por exemplo, seria interessante carregar funções dos módulos/pacotes importados no editor – em Python, eu poderia executar um import numpy e as funções do numpy poderiam estar disponíveis na complementação de código também. E seria bom se as variáveis na área de trabalho do Cantor estivessem disponíveis no editor de scripts.

Mas isto é um trabalho para o futuro. Por agora, você pode se divertir com essa nova complementação de código. E obrigado a todos os  desenvolvedores do Kate por esta funcionalidade!

por Filipe Saraiva em 01 de June de 2014 às 20:33

May 29, 2014

Elcio Luiz Ferreira

VISIE: 05.04 Precificação em projetos web

Como fazer precificação em projetos de software? Eu não tenho a resposta certa, mas sei umas coisas que podem ajudar.
Views:
0
0
ratings
Time:
05:23
More in
Science & Technology

O post VISIE: 05.04 Precificação em projetos web apareceu primeiro em fechaTag.

por elcio em 29 de May de 2014 às 14:16

May 27, 2014

Elcio Luiz Ferreira

May 26, 2014

Elcio Luiz Ferreira

VISIE: 05.02 Empreendedorismo no Brasil

Por que o governo brasileiro complica tanto a vida do empreendedor?
Views:
0
0
ratings
Time:
05:55
More in
Science & Technology

O post VISIE: 05.02 Empreendedorismo no Brasil apareceu primeiro em fechaTag.

por elcio em 26 de May de 2014 às 16:47

VISIE: 05.01 Educação para o empreendedorismo

Três coisas que você não aprendeu na escola: Finanças, Criatividade e Liderança.
Views:
0
0
ratings
Time:
06:10
More in
Science & Technology

O post VISIE: 05.01 Educação para o empreendedorismo apareceu primeiro em fechaTag.

por elcio em 26 de May de 2014 às 03:02

May 24, 2014

Kodumaro

Erlang vs Prolog

Poliedro

Simon Thompson Joe Armstrong criou Erlang a partir de Prolog – aliás, o primeiro compilador era escrito em Prolog.

[update 2014-05-25]
Faglia nostra: o programador Prolog e criador da linguagem Erlang é Joe Armstrong. Simon Thompson é o mantenedor e um dos resposáveis pela reescrita em C.
[/update]
Apesar de ser uma linguagem funcional, Erlang traz muita herança de Prolog e suporta o paradigma declarativo. Para demonstrar essa similaridade, vou colocar o código de fatorial: em Erlang e em Prolog, implementação simples (e ruim) e usando tail-call optimization.

Código Q&D

Vamos ao rápido e sujo, primeiro em Prolog:

fact(0, 1) :- !.
fact(N, F) :- N > 0,
N1 is N - 1,
fact(N1, F1),
F is N * F1.

Agora em Erlang:

fact(0) -> 1;
fact(N) when N > 1 -> N * fact(N - 1).

A intenção é mostrar como os códigos são parecidos.

Tail call optimization

Tanto Prolog quanto Erlang têm sistemas inteligentes de esvaziamento de pilha e usar um acumulador ajuda a tornar o programa mais eficiente.

O fatorial em Prolog fica assim:

fact(N, F) :- N >= 0,
fact(N, 1, F).

fact(0, F, F) :- !.
fact(N, A, F) :- N1 is N - 1,
A1 is N * A,
fact(N1, A1, F).

Agora em Erlang:

fact(N) when N >= 0 -> fact(N, 1).

fact(0, A) -> A;
fact(N, A) -> fact(N-1, A*N).

Bônus

Tente adivinhar em qual linguagem é este código:

fact(N, F) :- N >= 0, fact(N, 1, F).
fact(0) --> { ! }, '='.
fact(N) --> { N1 is N - 1 }, mul(N), fact(N1).
mul(N, A, R) :- R is N * A.


[]’s
ℭacilhας, ℒa ℬatalema

por noreply@blogger.com (ℭacilhας, ℒa ℬatalema) em 24 de May de 2014 às 22:58

Elcio Luiz Ferreira

VISIE: 04.07 Semeie sempre

“Pela manhã semeia a tua semente, e à tarde não retires a tua mão, porque tu não sabes qual prosperará, se esta, se aquela, ou se ambas serão igualmente boas.” Eclesiastes 11:6

Não seja ingênuo, mas

Views:
0
0
ratings
Time:
05:32 More in
Science & Technology

O post VISIE: 04.07 Semeie sempre apareceu primeiro em fechaTag.

por elcio em 24 de May de 2014 às 20:55

May 23, 2014

Elcio Luiz Ferreira

VISIE: 04.06 Compartilhe

Você não sabe o que vai ser útil para alguém. Há sempre alguém mais iniciante que você. Compartilhe.

Assine nossa lista: https://visiepw.leadpages.net/convite/

Views:
4
0
ratings
Time:
03:25 More in
Science & Technology

O post VISIE: 04.06 Compartilhe apareceu primeiro em fechaTag.

por elcio em 23 de May de 2014 às 13:50

May 22, 2014

Elcio Luiz Ferreira

VISIE: 04.05 Swipe it

Ofereça a melhor experiência mobile para seus usuários com touch events.

Assine nossa lista: https://visiepw.leadpages.net/convite/

Views:
2
0
ratings
Time:
03:27 More in
Science & Technology

O post VISIE: 04.05 Swipe it apareceu primeiro em fechaTag.

por elcio em 22 de May de 2014 às 15:44

May 21, 2014

Elcio Luiz Ferreira

VISIE: 04.04 Imagens para telas retina

Telas Retina, múltiplas resoluções, há uma solução simples de implementar.

Assine nossa lista: https://visiepw.leadpages.net/convite/

Views:
3
0
ratings
Time:
04:23 More in
Science & Technology

O post VISIE: 04.04 Imagens para telas retina apareceu primeiro em fechaTag.

por elcio em 21 de May de 2014 às 15:43

May 20, 2014

Magnun Leno

Palestra de Introdução ao Git

Há muito tempo atrás, eu e um grupo de pessoas participamos de um projeto chamado Criandeiros. Esse projeto gerou algumas palestras bem interessantes que já foram citadas aqui. Entretanto, devido a diversos fatores, esse grupo se desfez e eu postei por aqui apenas as palestras de Particularidades do Python e Modelo MVC.

git

Curiosamente, depois de gravar um episódio como convidado do SciCast, acabei me lembrando de uma palestra muito legal que eu preparei para o Criandeiros, o tópico era o versionador Git…

Palestra de Introdução ao Git é um artigo original de Mind Bending

por Magnun em 20 de May de 2014 às 16:00

Elcio Luiz Ferreira

VISIE: 04.03 localStorage e uso offline

Caiu a conexão, e agora? Dados locais, salvos com facilidade. Muito simples de implementar. Faça hoje mesmo.

Assine nossa lista: https://visiepw.leadpages.net/convite/

Views:
12
3
ratings
Time:
04:17 More in
Science & Technology

O post VISIE: 04.03 localStorage e uso offline apareceu primeiro em fechaTag.

por elcio em 20 de May de 2014 às 14:53

May 19, 2014

Allison Azevedo

Allisson

Depois de fazer um belo upgrade de memória (4gb -> 16gb) eu resolvi usar o Vagrant como plataforma de desenvolvimento, fiz uma nova instalação do Osx Mavericks e deixei o meu sistema o mais limpo possível, deixando tudo que é necessário para desenvolvimento na máquina virtual do vagrant.

Agora eu estou usando o Ubuntu Precise64 e tenho praticamente a mesma infra que uso nos servidores de produção, para provisionar essa máquina eu usei o Ansible e os arquivos de configuração eu deixei a disposição no meu Github.

Agora eu tenho tudo o que preciso para desenvolver ao alcance, basta usar o vagrant up e esperar a configuração do sistema.

O que vem incluso:

  • Mapeamento das portas dos servidores
  • Mysql 5.5, usuário e senha ‘allisson’
  • Postgresql 9.3 + Postgis, usuário e senha ‘allisson’
  • Nodejs via ppa
  • Mongodb via ppa
  • Redis e Memcached

Links:


por Allisson Azevedo em 19 de May de 2014 às 15:50

Elcio Luiz Ferreira

VISIE: 04.02 SVG

Conheça a tecnologia de gráficos vetoriais que pode tornar seu site muito mais leve e bonito.

Assine nossa lista: https://visiepw.leadpages.net/convite/

Views:
45
10
ratings
Time:
03:19 More in
Science & Technology

O post VISIE: 04.02 SVG apareceu primeiro em fechaTag.

por elcio em 19 de May de 2014 às 13:40

Kodumaro

PL Framework

Glider
Falei sobre como gerenciar dados mutáveis em Prolog. O código final ficou assim:


-*- Prolog -*-
:- module(profile, [profile/2]).
:- dynamic profile/2.

set(ID, X) :- profile(ID, X), !.
set(ID, X) :- X =.. [Attr, _],
E =.. [Attr, _],
retractall(profile(ID, E)),
assertz(profile(ID, X)), !.

set(_, []) :- !.
set(ID, [X|Rest]) :- set(ID, X), set(ID, Rest).

get(ID, R) :- findall(X, profile(ID, X), R).

drop(ID) :- retractall(profile(ID, _)).

Mas e se quisermos que os dados sejam persistentes, ou seja, sobrevivam entre execuções, como um banco de dados?

O dialeto SWI Prolog oferece um arcabouço com inúmeros recursos chamado PL Framework.

Para persistência, há a biblioteca persistency.pl.

O que temos de fazer é substituir algumas partes de nosso código pelos predicados da biblioteca. Começaremos importando o módulo: logo após a declaração do nosso módulo, na linha abaixo, acrescente a importação:
:- use_module(library(persistency)).

Em seguida, não precisamos mais declarar o predicado profile/2 como dinâmico, em vez disso vamos declarar uma persistência. Substituia a linha com dynamic por:
:- persistent profile(id:atom, attr:compound).

Agora precisamos subtituir as chamadas de retractall/1 por retractall_profile/2, protegidas por with_mutex/2.

Onde está:
              retractall(profile(ID, E)),

Substitua por:
              with_mutex(profile,
retractall_profile(ID, E)),

E substitua:
drop(ID) :- retractall(profile(ID, _)).

Por:
drop(ID) :- with_mutex(profile,
retractall_profile(ID, _)).

Agora precisamos substituir assertz/1 por assert_profile/2. Onde está:
              assertz(profile(ID, X)), !.

Substitua por:
              with_mutex(profile, 
assert_profile(ID, X)), !.

Você pode juntar os predicados dentro de with_mutex/2.

Precisamos agora de uma regra para conectar a uma base de dados em disco, por exemplo:
connect(File) :- db_attach(File, [gc]).

Se quiser um arquivo padrão:
connect :- connect('profile.db').

Código final com persistência

-*- Prolog -*-
:- module(profile, [profile/2]).
:- persistent profile(id:atom, attr:compound).

set(ID, X) :- profile(ID, X), !.
set(ID, X) :- X =.. [Attr, _],
E =.. [Attr, _],
with_mutex(profile,
(retractall_profile(ID, E),
assert_profile(ID, X))), !.

set(_, []) :- !.
set(ID, [X|Rest]) :- set(ID, X), set(ID, Rest).

get(ID, R) :- findall(X, profile(ID, X), R).

drop(ID) :- with_mutex(profile,
retractall_profile(ID, _)).

connect :- connect('profile.db').

connect(File) :- db_attach(File, [gc]).

Este artigo foi apenas um exemplo prático de Prolog.

[]’s
ℭacilhας, ℒa ℬatalema

por noreply@blogger.com (ℭacilhας, ℒa ℬatalema) em 19 de May de 2014 às 12:46

Elcio Luiz Ferreira

VISIE: 04.01 Formulários do HTML5

Campo e-mail como e-mail, número como número, data como data. Veja como HTML5 pode melhorar a experiência dos usuários ao preencher formulários, com técnicas simples que você pode colocar em prática hoje mesmo.

Assine nossa lista: https://visiepw.leadpages.net/convite/

Views:
53
4
ratings
Time:
04:19 More in
Science & Technology

O post VISIE: 04.01 Formulários do HTML5 apareceu primeiro em fechaTag.

por elcio em 19 de May de 2014 às 04:30

May 18, 2014

Elcio Luiz Ferreira

VISIE: 03.07 Correr atrás do vento

Pare de correr sem pensar e tome tempo para refletir.
Views:
32
5
ratings
Time:
04:47
More in
Science & Technology

O post VISIE: 03.07 Correr atrás do vento apareceu primeiro em fechaTag.

por elcio em 18 de May de 2014 às 05:30

May 17, 2014

Kodumaro

Pequeno glossário de Prolog

Glider Ontem eu escrevi um artigo simples sobre Prolog.

O artigo na Wikipédia em português me pareceu pouco completo e bastante confuso. Tem informações legais lá, mas em comparação com a versão em inglês deixa a desejar.

Não pretendo completar o que está escrito na Wikipédia (senão deveria completar lá), apenas descomplicar um pouco.

Pra começar, é preciso entender a estrutura de um programa em Prolog: consiste em um domínio de verdades, parecido com uma base de dados, e o ponto de entrada é uma pergunta (query). Dito isso, vamos definir os conceitos dentro do código:
  • Termo: qualquer dado em Prolog é chamado termo.
  • Átomo: é um nome de propósito geral sem significado inerente. É representado por uma sequência de letras e alguns caracteres, começando por uma letra minúscula, ou qualquer sequência entre piclas ('…'). Por exemplo: hanoi
  • Número: pode ser inteiro ou de ponto flutuante, não diferente de outras linguagens.
  • Termo composto: consiste em um átomo, chamado functor (que é uma cabeça ou cabeçalho) seguido de uma sequência de termos e/ou incógnitas separados por vírgulas e entre parêntesis, chamada argumentos. Por exemplo: hanoi(5, R)
  • Predicado: é uma função booleana, ou seja, que retorna verdadeiro ou falso. Um predicado pode ser um átomo ou um termo composto e deve ser definido por um fato ou por uma regra.
  • Operador: é um predicado normal de aridade 2, mas que pode ser representado de forma diferente. Por exemplo, o sinal de igual:
X = 2

É o mesmo que:
'='(X, 2)

  • Variável: prefiro evitar a expressão “variável”, pois ela é falsa, apesar de ser o nome oficial. Prefiro “incógnita”: a incógnita pode estar ligada (bound) ou não (unbound) a um termo e tem comportamento diferente de acordo com estar ou não ligada. É representada por uma sequência de letras iniciando por uma letra maiúscula ou um underscore (_). Por exemplo: X
  • Fato: indica que determinado predicado retorna verdadeiro. É um átomo ou termo composto seguido de um ponto. Por exemplo:
default(5).

  • Regra: condiciona o resultado de um predicado ao resultado de outro. É um átomo ou termo seguido de :- e então o predicado ao qual ele está condicionado. Por exemplo:.
move(_, X, Y, _, R) :- move(1, X, Y, _, R).

  • Pergunta (query): É a chamada de um predicado. Pode retornar verdadeiro, falso ou gerar uma exceção. No código, é uma linha iniciada por :- e terminada por ponto. No prompt ?- basta digitar o predicado seguido de um ponto e pressionar a tecla Enter.

Um detalhe importante é que coisas que não parecem predicados, também são! Por exemplo:
  • Vírgula: é operador (','/2) que avalia o primeiro um predicado (argumento) e só avalia o segundo se o primeiro for verdadeiro, ou seja, E lógico.
N1 is N - 1, fact(N1, F1)

  • Ponto e vírgula: operador (';'/2) que avalia o primeiro predicado e só avalia o segundo se o primeiro for falso, ou seja, OU lógico.
  • Exclamação: é um predicado de aridade 0 ('!'/0) que indica que, se a regra atual “casar” (match) com a pergunta, os próximos fatos ou regras não serão avaliados.
  • Qualquer operação matemática.

Como exemplo, segue uma implementação da resolução da torre de Hanói:
% -*- Prolog -*-
:- module(hanoi, [hanoi/0, hanoi/1, hanoi/2]).

hanoi :- hanoi(R), findall(_, show(R), _).
hanoi(R) :- default(N), hanoi(N, R).
hanoi(N, R) :- N > 0,
findall(X,
move(N,
'a esquerda',
'a direita',
'o centro', X),
R).

default(5).

move(1, X, Y, _, move(X, Y)) :- !.
move(N, X, Y, Z, R) :- N1 is N - 1, move(N1, X, Z, Y, R).
move(_, X, Y, _, R) :- move(1, X, Y, _, R).
move(N, X, Y, Z, R) :- N1 is N - 1, move(N1, Z, Y, X, R).

show(move(X, Y)) :- format('mova o disco d~w para ~w~n', [X, Y]).
show([X|_]) :- show(X).
show([_|Rest]) :- show(Rest).

Consegue entender como funciona?

Para gerar um executável com SWI Prolog:
bash$ prolog -f hanoi.pl \
-g 'use_module(library(save)), qsave_program(hanoi, [goal(hanoi)])' \
-t halt

Bônus

Há um açúcar sintático em prolog, que é -->:
a --> b, c(x), d.

Significa o mesmo que:
a(Start, End) :- b(Start, V1), c(x, V1, V2), d(V2, End).

[]’s
ℭacilhας, ℒa ℬatalema

por noreply@blogger.com (ℭacilhας, ℒa ℬatalema) em 17 de May de 2014 às 13:13

Dados em Prolog

Glider Há uns anos falei um pouquinho sobre Prolog: sobre predicados, átomos, termos compostos, fatos, regras, incógnitas, etc.

Só pra relembrar: um programa em Prolog é um conjunto de predicados – fatos e regras – e sua execução consistem em perguntas (queries) feitas a esse domínio de verdades. Na programação declarativa, a ideia não é dizer como o computador deve resolver o problema, mas sim descrever o problema.

O entendimento de Prolog é essencial ao entendimento da programação declarativa e, assim, para poder extrair o máximo do poder de linguagens mais modernas, como Erlang.

É uma história bonita, mas um exemplo um pouco mais prático iria bem, não?

Então imaginei um exemplo: um módulo que representa perfis de dados – por exemplo, dados de perfil de usuário.

Podemos começar o código dizendo para o sistema nosso módulo:
% -*- Prolog -*-
:- module(profile, [profile/2]).

A primeira linha é um comentário que avisa a alguns editores que o arquivo se trata de um código Prolog, a segunda declara o módulo profile, que exporta o predicado profile/2 (com aridade 2).

A seguir, podemos declarar nosso predicado profile/2:
:- dynamic profile/2.

Essa declaração diz que o predicado profile/2 é dinâmico, ou seja, muda ao longo da execução do programa.

Agora precisamos de um predicado para gravar novos dados de perfil. Façamos isso com uma regra:
set(ID, X) :- profile(ID, X), !.

Essa regra diz ao sistema que, se alguém questionar set(ID, X) – onde ID é o identificador do perfil e X é um atributo do perfil – e essa combinação for verdadeira, ele não deve assumir isso como ver dade e não avaliar demais regras ou fato (!).

A próxima regra é um pouco longa, então vou falar dela linha a linha:
set(ID, X) :- X =.. [Attr, _],

Aqui diz que o predicado é set(ID, X) (exatamente igual ao anterior), e X é um termo composto de aridade 1, cujo cabeçalho será atrelado à incógnita Attr.

Caso verdade, continua a próxima linha da regra:
              E =.. [Attr, _],

Então E é termo composto com mesmo cabeçalho e aridade de X, porém com parâmetro _, que significa qualquer coisa.

Então, se X for name(john), E será name(_).
              retractall(profile(ID, E)),

Remove o predicado com o dado de perfil com o mesmo identificador e o mesmo cabeçalho informados.
              assertz(profile(ID, X)).

Cria o predicado armazenando o atributo de perfil informada – e assim termina nossa regra.

E se quisermos criar uma lista de atributos para o mesmo identificador de perfil?

Podemos criar um predicado para isso. Comecemos pelo ponto de parar, que é quando nossa lista de atributos já foi esgotada:
set(_, []) :- !.

Essa regra diz que, se a lista de atributos está vazia, não precisa fazer mais nada. Mas e se contiver algum elemento? Precisaremos questionar o set/2 para aquele atributo e continuar chamando para o resto da lista:
set(ID, [X|Rest]) :- set(ID, X), set(ID, Rest).

Resolvido.

Podemos criar um predicado para retornar todos os atributos de uma identidade:
get(ID, R) :- findall(X, profile(ID, X), R).

Precisamos agora de um predicado de limpeza, um para remover todos os atributos de um identificador (o que significa apagar o identificador):
drop(ID) :- retractall(profile(ID, _)).

Vamos testar agora nosso módulo:
?- [profile].
true.

?- profile:set(1, [name(john), age(20), city(rio)]).
true.

?- profile:set(2, [name(jack), age(21), city(sao_paulo)]).
true.

?- profile(ID, city(City)).
ID = 1
City = rio ;
ID = 2
City = sao_paulo.

?- profile:get(1, R).
R = [name(john), age(20), city(rio)].

?- profile:drop(1).
true.

?- profile(ID, _).
2 ;
2 ;
2.

?- drop(_).
true

?- profile(ID, _)
false.

?-

Espero que o exemplo tenha sido esclarecedor. Para fazer um tracing, você pode fazer a pergunta gtrace.

Observação: para a execução, foi usando SWI Prolog, uma das mais confiáveis e robustas implementações de Prolog da atualidade.

Complemento a este artigo: Pequeno glossário de Prolog.

[]’s
ℭacilhας, ℒa ℬatalema

por noreply@blogger.com (ℭacilhας, ℒa ℬatalema) em 17 de May de 2014 às 03:20

May 16, 2014

Magnun Leno

Corrigindo Arquivos CSV com Python

Ontem eu estava conversando com alguns colegas e um deles acabou soltando que estava tendo que fazer um trabalho braçal: Corrigir um arquivo CSV manualmente, pois a rotina que processava sua entrada só compreendia campos do CSV se eles estivessem envolvidos entre aspas duplas.

CSV

Na hora eu falei pra ele, "Use Python!", e em seguida todos me disseram que era trabalho demais escrever um programa só pra isso. Será mesmo?

Corrigindo Arquivos CSV com Python é um artigo original de Mind Bending

por Magnun em 16 de May de 2014 às 17:32

Elcio Luiz Ferreira

VISIE: 03.06 Teste os concorrentes

Veja o que já existe por aí antes de construir seu produto.
Views:
34
6
ratings
Time:
03:30
More in
Science & Technology

O post VISIE: 03.06 Teste os concorrentes apareceu primeiro em fechaTag.

por elcio em 16 de May de 2014 às 16:18

May 13, 2014

Magnun Leno

Hack ‘n’ Cast v0.1 - Cultura Hacker

Hackers não são criminosos cibernéticos que invadem seu computador ou roubam seus e-mails, o nome disso é cracker. Sabia que os hackers na verdade são praticamente os responsáveis pela internet, pelo sistema operacional Unix, OS X, Gnu/Linux e etc? Sabia que os hackers não se limitam apenas ao mundo da tecnologia?

Baixe o episódio e leia o shownotes

por Magnun em 13 de May de 2014 às 14:22

May 08, 2014

Elcio Luiz Ferreira

VISIE: 02.05 Sobre Documentação

Documentação de software é uma arte difícil. Pouca documentação é ruim. Documentação demais é ainda pior.
Views:
4
0
ratings
Time:
08:18
More in
Science & Technology

O post VISIE: 02.05 Sobre Documentação apareceu primeiro em fechaTag.

por elcio em 08 de May de 2014 às 20:14