Novo Blog

Novo endereço

https://blog.nilo.pro.br

sábado, 21 de julho de 2012

Certificados e diplomas em informática

Leia no novo blog

Esta foi a resposta que dei num post na lista Python-Brasil sobre a importância de certificados.

Há alguns anos eu contratei mais de 100 profissionais de informática... desenvovedores C++, Java, testadores etc. Durante este período, eu aprendi a não confiar em diploma algum.

Eu contratei gente vinda de faculdade particular muito melhor que de faculdades federais ou estaduais, embora esta não fosse a regra, mas a exceção. Se a pessoa que contrata é a mesma que vai trabalhar com você, por exemplo seu futuro chefe, ele procura alguém que resolva os problemas dele, diploma e certificado ele deixa para o RH ver :-D. Eu conheci muita gente boa que nem faculdade tinha, mas são casos raros e não a regra. Para algumas posições de TI, faculdade é luxo... para outras é absolutamente necessário. Eu sei que para administração de redes, certificação é fundamental.

A questão de diploma/certificados aparece quando você tenta trabalhar numa empresa maior onde:

a) Alguém do RH ou empresa externa vai fazer a pré-seleção para o pessoal de TI. Neste caso, a primeira seleção é quase mecânica com um check list do CV: tem faculdade? É de informática ou engenharia? trabalha há quantos anos... etc. Normalmente o RH não arrisca passar um CV para entrevista se nem tiver encontrado alguns pré-requisitos. Algumas empresas tem mesmo cotas de qualidade e escolarização, onde uma determinada porcentagem tem que ter mestrado, doutorado ou graduação. Onde eu trabalhei, nosso cliente pedia um inventário de talentos e diplomas. Neste caso, é importante aparecer a palavra Python, seja na sua experiência, ou mesmo no nome de um curso que você fez (mais abaixo).

b) A pessoa recebe um número excessivo de CVs para a mesma vaga, na época eu recebi mais de 2200. Neste caso, ela vai fazer um pesquisa como o pessoal de RH. Normalmente se privilegia experiência nesses casos, mas sem os diplomas, depende muito. No meu caso, minha secretária era professora de inglês. Eu passava uns CVs pré-selecionados para ela, ela ligava, fazia um teste por telefone e filtrava os CVs que eu deveria chamar para entrevista, sorte minha.

Eu comecei a trabalhar cedo com informática (início dos anos 90) e até meus 28 anos eu não tinha diploma universitário. Ná época, o importante para mim era ganhar dinheiro. Consegui ótimas vagas em empresas pequenas, apenas com um diploma do curso técnico. Nunca fiz certificação alguma. Nunca trabalhei em mega-empresas, pois o salário dependia da formação e nunca era bom para mim (pagavam menos).
Depois eu me formei e fiz mestrado. Valeu muito a pena na hora de trabalhar fora, pois para ter permissão de trabalho o diploma é obrigatório (pelo menos na Bélgica). Aqui, nem de certificação ouço falar, mas um "engenheiro" passa 5 anos na faculade em tempo integral. Aqui já se sai mestre. Escrevi "engenheiro", pois aqui esta palavra praticamente substitui o nosso graduado.

Como você mesmo disse, toda forma de adquirir conhecimento é importante. Se eu morasse em SP, eu assistira o curso do Luciano, tenho certeza que o networking e os bizus de Python apareceriam, independente do meu nível de formação ou experiência. Um curso online pode ser muito bom, mas depende muito. Eu fiz uns no Cursera, uns excelentes e outros que não consegui nem chegar ao fim. Tudo depende, só de experimentar já se aprende muito.

Quanto a certificado de curso livre, sinceramente, nunca serviram para nada, na minha experiência. Se for fazer o curso, faça para aprender. O certificado só serve para o RH fazer o tal  inventário de talentos mais tarde e se para isso servir. Eu tenho maior orgulho de um curso de programação Basic I que fiz em 86... mas nunca tive oportuinidade de usá-lo, ficou como recordação mesmo.

Se eu voltasse a contratar hoje, eu daria preferência para pessoas que saibam aprender sozinhas. Seja com livros, cursos presenciais ou on-line, mas alguém que se vire para aprender um assunto. Nessa lista, vale até que aprendeu Python lendo a documentação on-line que é ótima. Mas se eu tivesse que escolher entre dois candidatos com experiência equivalente, mas um formado e outro não, o com diploma teria a vaga.

Três coisas são importantes num CV: experiência, formação superior e em alguns casos certificações.

Cursos livres eu não colocaria nem no CV. Salvo se o CV estiver muito magrinho. Se o curso foi de Python, é mais importante dizer que sabe e que ja fez X, Y e Z com a linguagem. O curso livre pode aparecer na entrevista. O networking do curso pode ajudar mais que o curso em si, mas lembre-se que isso pode ser uma faca de dois gumes, pois estas pessoas lembrarão de como você se comportou no curso, nos intervalos, etc.

Resumindo, eu faria um curso online, independente do certificado, se quisesse acelerar o aprendizado de uma linguagem/assunto. Mas não ficaria só por ai.

terça-feira, 17 de julho de 2012

De volta à Alemanha

Comecei meu estágio em Braunschweig... 10 anos depois de Munique, me deparo com problemas bem diferentes. Munique é uma cidade grande... Braunschweig tem 250 mil habitantes. A estrutura é muito boa, mas diferentemente de Munique, só com inglês você não faz tudo :-(
10 anos mais velho, aprender alemão deixa de ser tão divertido. A falta de novidades faz tudo virar rotina bem rápido. Pelo menos está chovendo menos que em Mons :-D



sábado, 28 de abril de 2012

Gênesis Informático

Como estou quase sendo obrigado a programar em Java de novo, fica a piada:

No início não havia computadores, apenas máquinas.

As máquinas existiam, mas a lógica era limitada.

O homem domou a corrente elétrica e a transformou em sinais digitais capazes de  transportar infomação.

Tudo era nulo, apenas bits 0.

Criou-se então os bits 1.

Surge a lógica.

Mas os bits 0 e 1 eram sós e o byte foi criado para agrupá-los.

Bits e bytes sem nome vagavam pelas máquinas, sem saber o que fazer. As máquinas ainda eram criadas para uma finalidade bem específica e a lógica codificada no material. Surgiam os primeiros sistemas.

O programador foi então criado e a ele foi dada a responsabilidade de organizar bits e bytes. Surgia o Caos.

Mas o programador era só e criou linguagens e compiladores para acompanhá-lo. O sistema enviou mensagens dizendo que aquilo era perigoso e que agora milhões de bits e bytes teriam que ser utilizados para fazer as coisas mais simples. A mensagem foi ignorada e surgia assim o bug.

O programador continuou proliferando código escrito em múltiplas linguagens. Quando inventou o C, o sistema enviou uma nova mensagem dizendo que já era suficiente e que o programador deveria se contentar com bits, bytes e ponteiros, todos felizes na RAM.

O C era bom e foi usado para criar o UNIX.

O diabo, invejoso, criou o Windows para atentar o programador por toda sua existência.

Novos programas foram criados a partir desses princípios básicos entre o universo de software e hardware. Um dia, o programador traiu o sistema e criou jAdao e jEva, escrenvendo-os num dialeto de C++ banido aos habitantes da ilha de Java. O sistema então castigou jAdao e jEva por terem acumulado tantos bits e bytes a ponto de usar toda a memória do sistema e os baniu para Java dizendo:

Usarás o dialeto no teu dia-a-dia.
Esquecerás o que é um bit.
Usarás um IDE lento.
Verás tudo através deste código que não conhecerá limites de tamanho, performance ou coerência.
Jamais tocarás num ponteiro.
Teus descendentes não usarão propriedades e todos os programadores terão que escrever getters e setters pelo resto de seus dias.
Teu código só entenderá XML e produzirá logs indecifráveis.
Serás atormentado por cobras e outras pedras preciosas que não sofrerão desses males, serão menores e mais ágeis, porém ainda mais lentas.
Tuas classes proliferarão e dominarão o mundo.
Este dialeto será portátil e te acompanhará por todas as máquinas que usares, sempre pendindo para fazer update.





sábado, 4 de junho de 2011

A Era do Javascript

Leia no novo blog

Meus primeiros contatos com Javascript datam de uma época distante, onde o Netscape era o mais popular browser da Internet! Eu usava um servidor Sun e estudava um produto chamado Netscape One, que vinha com uma tecnologia de script do lado servidor chamada de LiveScript. Ela já era também disponível no browser, mas não prestava para muita coisa na época. As tecnologias quentes eram o CGI e o SSI. Eu me interessava também pela novidade do momento, a tal de PHP 3 ! Se minha memória não falha, estou falando do período de 95 a 98.

Tecnologias como Java Applets nunca "pegaram", sempre foram consideradas lentas demais, pesadas demais. Já com o Javascript, além de lento, não se podia fazer muita coisa. A maior parte dos trabalhos se limitava a validação de campos e tarefas menores com strings e datas. Jogos em Javascript, só de forca e da velha. Nessa época eu escrevia CGI's em C++ e lembro da magia que foi aprender a programar em Perl.

Javascript nunca foi uma linguagem "seria" até alguns anos atrás, quando ficou impossível de ser ignorada. No lançamento do iPhone, muitos ficaram chocados com idéia inicial da Apple de aplicações web com Javascript... depois é que eles liberaram aplicações nativas. Isso já em 2007... mas a maioria dos celulares tinha browsers de Internet sofríveis, muitos sem Javascript. Hoje vemos compiladores de e para Javascript, compactadores, obfuscadores e uma infinidade de livros. Javascript está instalada na maioria dos computadores do mundo, incluindo telefones celulares e mesmo sistemas embarcados. Você pode até mesmo usar Javascript para instrumentar seu programa escrito em Java ou C++! É impossível ignorar a força do Javascript. A prova final para mim foi há algumas semanas quando vi uma pequena máquina virtual, suficientemente completa para rodar o kernel do Linux em Javascript, fora jogos como Doom e emuladores diversos, completamente escritos ou portados para Javascript!

A impressão que tenho é o mesmo que aconteceu na década de 80, onde para se ter velocidade programava-se em Assembly, mas era difícil e cada micro tinha o seu próprio Assembly incompatível. Isso era nítido na programação de jogos. Até nas revistas, os programas eram escritos parte em Basic, parte em Assembly. Com o passar do tempo, ficou prático escrever em Pascal e C, compiladas e muito mais fáceis que Assembly. Com o Javascript acontece a mesma coisa, quando começo a ver a quantidade de compiladores que agora geram códigos em Javascript, tenho a mesma impressão. Como escrever grandes programas em Javascript ainda é difícil, diversas bibliotecas e ferramentas podem ser utilizados para reduzir este esforço. Uma dessas ferramentas é a CoffeScript, que dá uma sintaxe limpa ao Javascript, inspirada em Python. É como se essas linguagens estivessem fazendo o trabalho que C e Pascal fizeram antes e o Javascript sendo o novo Assembly universal, afinal é suportado pela maioria dos micros e é multiplataforma. Não falo aqui que o Javascript substitui o Assembly, nada disso. Apenas um posicionamento das linguagens como ferramenta num cenário de aplicações global.

Como tudo agora é na ou para a Web, Javascript é incontornável. A popularização do suporte a HTML 5 nos browsers só vem a ajudar. Nos últimos anos, motores Javascript de alta performance se popularizaram no Google Chrome, FireFox, Safari e até mesmo no Internet Explorer! Canvas, WebGL, bancos de dados locais, web sockets, web workers, tudo disponível em praticamente qualquer browser, via Javascript! 

sábado, 12 de março de 2011

Khan no TED


Eu ainda me impressiono com a Khan Academy. Fantástica ferramenta para quem precisa relembrar e aprender conceitos de matemática, física, etc. Agora ele ataca problemas de nivelamento entre estudantes com ritmos de aprendizagem diferente. Quando teremos este tipo de iniciativa em português? Vídeos e não mini novelas! O potencial das video aulas, com playback controlado pelos alunos é interessante, mesmo em áreas sem Internet ou infra-estrutura para video aulas transmitidas ao vivo.

terça-feira, 8 de fevereiro de 2011

Programe ou seja programado

Leia no novo blog
Eu vi este vídeo ano passado, mas como não tinha legendas em português... não o coloquei aqui.
Porém, mesmo sem legendas, estas ideias não poderiam ficar sem um comentário breve.
Assista ao vídeo:



Douglas Rushkoff apresenta a importância do conhecimento de programação no mundo moderno.
Não que ele defenda um mundo de programadores ou que aborde uma linguagem de programação X ou Y.
O que é fantástico no vídeo é a relação entre a invenção da escrita, programação e as mídias modernas.
Do início do compartilhamento do conhecimento através da escrita, de livros e depois com a invenção da prensa moderna, ele compara o acesso do cidadão comum a cada uma destas formas de transmissão do saber. Como esse conhecimento era controlado e distribuído entre as pessoas comuns e como sempre a sociedade comum estava um passo atrás das últimas tecnologias de produção e distribuição deste mesmo conhecimento.

A questão é realmente saber se hoje estamos ficando para trás, ao não incluirmos a programação no mundo de nossos filhos. Hoje, tão importante quanto ler e escrever, programar é necessário. De uma simples planilha a sistemas complexos, diferentes níveis de programação são utilizados. Assim como a invenção da escrita não levou a uma sociedade de escritores, como apresentado no vídeo, a programação não criará uma sociedade de programadores. O ponto é realmente ter ideia do que pode ser programado, de ter noções básicas de como as coisas funcionam e não de simplesmente utilizar os meios como nos são fornecidos: Twitter, Facebook, Google e mesmo a web.

O vídeo postado pela Wilmara no Facebook me chamou a atenção para o problema da educação:



Isso me fez pensar no por quê meus filhos ainda perguntam que língua é falada em tal ou tal país... tendo a Wikipédia e o Google disponíveis. Eles sabem acessar o Facebook, jogos e principalmente o YouTube. Mas a capacidade de síntese não é dada ou ensinada na escola. Continuamos a ensinar a decorar e não a reunir novas informações e criticar o conhecimento. Lembro do tempo que passei para achar o nome científico de 10 animais quando estava no primário... hoje isso seria feito em segundos!

O foco continua sendo: ler, memorizar, repetir. Eu fui confrontado com esta realidade no meu primeiro emprego, como professor de lógica de programação. Os alunos estavam na faixa dos 15 anos, e eu tinha acabado de completar 18. Quando começamos a trabalhar com problemas simples de matemática, como porcentagens e proporções a casa caiu. Isso era muito estranho, pois eu era professor numa escola técnica, digamos elitista do ponto de vista que você tinha que ser aprovado num concurso para estudar lá. Não eram alunos ruins ou com problemas de aprendizado, mas alunos acima da média! O que alguns tinham dificuldade era em como utilizar o conhecimento passado através de exercícios de cálculo para uma nova realidade. Repito, não era problema em calcular, mas de saber que técnica já conhecida utilizar para resolver um problema similar, mas em outro contexto. Era simplesmente desenvolver suas equações, escrever enunciados de novos problemas, aplicar o que já sabiam, o contrário da forma como tinham sido preparados a vida toda!

Traçando um paralelo: será que ao invés de apenas deixar nossas crianças assistirem vídeos no YouTube, deveríamos ensiná-las a criar seus próprios vídeos? A escrever corretamente, ou pelo menos tentar escrever corretamente, usando wikis e mesmo criando suas próprias home pages? Aqui falamos de programação em sentido mais amplo, como dominar as ferramentas que utilizamos. Afinal, eu não sou artista, mas recebi noções básicas de arte na escola... ainda sei combinar cores, embora não saiba desenhar ou pintar. Precisamos ensinar nossas crianças a dominar as novas mídias. Não para criar uma sociedade de programadores, mas para evitar que eles simplesmente consumam conhecimento sem a menor noção de como este é produzido, armazenado, disponibilizado e principalmente as formas que pode ser controlado.

Vídeo bônus:

Only at OR Books: Program or Be Programmed by Douglas Rushkoff from OR Books on Vimeo.

quinta-feira, 2 de dezembro de 2010

Livro de Introdução Programação com Python já está venda

Leia no novo blog

Nada como uma noite fria e cheia de neve para colocar o blog em dia!
Meu livro de programação foi publicado pela Editora Novatec e já está disponível para venda.
Eu criei uma página sobre o livro, com links para livrarias e emails de contato:

http://www.nilo.pro.br/iprog/

O livro foi escrito de forma a apresentar novos conceitos gradualmente, com exemplos e exercícios.   Quando comecei a dar aulas, eu ensinava Basic e Pascal. Com o Basic, tinha o problema dos números de linha. Com o Pascal os ponto-e-vírgula... era muita coisa para escrever antes de começar a programar. Nestes casos, o uso de um pseudo-código claro e simples, livre de símbolos em excesso era interessante. Eu evitei usar pseudo-código ou fluxogramas, pois acredito que ao se aprender a programar, o melhor é ir direto ao ponto. Com a linguagem Python, isso tudo fica muito mais simples. Escrever em pseudo-código pode até ser mais complicado que escrever em Python!
O leitor/aluno precisa ver algo acontecer para continuar estudando. O importante é saber ler o programa e entender o que vai acontecer quando o programa for executado. Eu realmente acredito que o aluno deve saber se o programa está correto antes de executá-lo. A execução é apenas uma confirmação. Uma seção sobre rastreamento foi incluída no livro, para preservar esta importante etapa no aprendizado de programação.

A clareza e simplicidade da linguagem são realmente muito importantes para facilitar o aprendizado. Python torna a programação acessível par estudantes de outras áreas e não apenas de computação e engenharia.
Outra característica do Python é que ela permite usar quase tudo que temos no computador. Uma vez aprendendo a programar em Python, pode-se continuar estudando outras linguagens de programação ou partir diretamente para aplicações web, jogos, banco de dados, etc. O caminho é mais suave e sem interrupções. Não serve apenas de linguagem introdutória, mas do dia a dia.

Escrever um livro era algo que eu sempre quis fazer. Dá muito trabalho, tem que ler, reler, re-escrever e corrigir inúmeras vezes. O trabalho de revisão é realmente incrível, principalmente com a nova ortografia e com os desafios de escrever um livro técnico para leigos. Ter uma editora ajuda muito nesta tarefa, pois sozinhos nós começamos a não perceber mais os erros. Digo nós porque minha esposa ajudou na revisão.


Título: Introdução à Programação com Python
Autor: Nilo Ney Coutinho Menezes
ISBN: 978-85-7522-250-8
Páginas: 224

Editora: Novatec
Ano: 2010


Resenha do Livro:


Este livro é orientado ao iniciante em programação. Os conceitos básicos de programação, como expressões, variáveis, repetições, decisões, listas, funções e arquivos, são apresentados um a um com exemplos e exercícios. A obra visa explorar a programação de computadores como ferramenta do dia a dia. Ela pode ser lida durante um curso de introdução à programação de computadores e usada como guia de estudo para autodidatas. Para aproveitamento pleno do conteúdo, conhecimentos básicos de informática, como digitar textos, abrir e salvar arquivos, são suficientes. Todo software utilizado no livro pode ser baixado gratuitamente, sendo executado em Windows, Linux e Mac OS X.
Embora a linguagem Python (versão 3.x) seja muito poderosa e repleta de recursos modernos de programação, este livro não pretende ensinar a linguagem em si, mas ensinar a programar. Alguns recursos da linguagem não foram utilizados para privilegiar os exercícios de lógica de programação e oferecer uma preparação mais ampla ao leitor para outras linguagens. Essa escolha não impediu a apresentação de recursos poderosos da linguagem, embora o livro não seja fundamentalmente uma obra de referência.

Sumário (PDF)

sexta-feira, 13 de agosto de 2010

Um vídeo sobre educação

A pensar:



Disponível com legendas em português e outras línguas.
Clique em View Subtitles e depois em portuguese (Brazil).

domingo, 11 de julho de 2010

Como não desenvolver software

Eu nunca vi dois programadores desenvolverem o mesmo programa da mesma forma. Dizer o que é certo em desenvolvimento de software é muito difícil, tudo depende de quais correntes de pensamento você segue. Orientação a objetos, script-maníacos, programação funcional? Tem espaço para todo mundo e ninguém escapa em maior ou menor grau de vários sintomas aqui descritos.

Algumas coisas são tão ruins que mesmo em um assunto tão "quente" como desenvolvimento de software, pode-se achar um consenso. Eu vou relatar algumas das más práticas que conheci, pois acredito que elas são bastante comuns, especialmente com as novas tecnologias, Internet e código open source. Quanto maior o time de desenvolvimento, mais frequentes ficam esse pequenos problemas. O intuito deste post é relatar algumas experiências com o mesmo rigor científico de uma conversa de bar. Todas as afirmações são relativas e dependem do humor de quem as lê. Tudo deve ser encarado com várias pitadas de sal e bom humor. Eu avisei :-D
  • Over-engineering: quem nunca viu um pequeno exemplo com 1000 linhas de código não sabe do que estou falando... era para ser um "Hello World"... 1000 linhas depois ninguém sabia o que era. Um programa de computador precisa ser razoavelmente robusto a falhas, mas existe uma grande diferença entre uma aplicação crítica e uma aplicação simples, que pode simplesmente parar de funcionar e dar uma mensagem de erro! O sintoma se apresenta quando a confiabilidade do Sol começa a ser posta em jogo. E a pergunta cruel surge: quando o Sol explodir, o que faremos? Variações desta realidade são exigências como confiabilidade e disponibilidade de sistemas web comparáveis às do Facebook ou do Google, exceto que você ainda não tem o tráfego nem o dinheiro destes sites. Variações incluem o desejo incotrolável de utilizar o maior número de patterns no maior número de classes possível. Nada pode ser feito em apenas uma classe. Classes ficam melhor em dúzias. Porque deixar para um futuro refactoring o que já pode ser feito hoje?
  • Paralisia por análise: quando os programadores se lançam na quest máxima: a busca DO framework. Perdem-se às vezes meses com experimentos para simplesmente escolher um novo framework, ignorando toda a experiência anterior do time, ou que o tempo perdido não volta mais. Em informática é muito difícil escapar desta situação, principalmente com software open source, constantemente atualizado e melhorado. Parar de trocar pode simplesmente significar a morte do programador, ou sua condenação ao castigo máximo, como programar para sempre em Clipper ou Cobol :-D A questão é que uma decisão deve ser tomada e normalmente nenhum framework oferece solução para tudo, ou torna tudo simples, fácil e claro. Algumas pessoas buscam soluções que "não dão trabalho", mas esquecem que o fruto desta automatização é normalmente seguir padrões e conceitos do novo framework, conceitos que demandam tempo para ser aprendidos. Uma mistura de paralisia por análise com over-engineering é quando o time resolve encontrar uma solução perfeitamente escalável, adaptável a qualquer cliente e que possa rodar por uns 10 anos com pouca manutenção... ou seja, buscam alcançar o nirvana da programação. Isso não é desculpa para não analisar as melhores alternativas para resolver o problema, mas esta análise não deve durar mais tempo que o desenvolvimeno da solução em si.
  • Bala de prata: é quando o time decide resolver tudo com a mesma tecnologia sempre. Normalmente com C ou Java, mas começam a aparecer mais e mais casos com linguagens scripts. A verdade é que não existe bala de prata (no sentido de solução universal), nem lobizomem. Toda solução deve ser cuidadosamente analisada, dentro de um prazo bem definido, para não cair no problema da paralisia. Já se dizia há muito tempo: "Se a única ferramenta que você conhece é um martelo, tudo vira prego". 
  • Time Bom Bril: é o sonho de todo gerente de software. Um time multiplataforma, multilinguagem, com profissionais altamente inteligentes, simpáticos e dóceis. Entre outras características deste tipo de alucinação é usar "O time" em todo e qualquer tipo projeto, ignorando o conhecimento de domínio. Hospital, eleições, lançamento de foguetes, hardware? Não tem problema, "O time" resolve. Além deste tipo de patia causar danos ao pobres membros do time, a perda de produtividade é enorme, causando a aparição do folclórico Jack-of-all-trades-master-of-none. Ninguém consegue dominar tudo e alcançar resultados excelentes em tudo, isso é ilusão. Profissionais altamente capazes podem aprender muito rápido e superar o resultado de times ordinários, mas isso tem um preço. A pulverização de esforços e a constante pressão podem queimar um time de desenvolvimento muito rápidamente.
  • Cada um por si e ninguém por todos: muitos chefes atrapalham, mas quando não há algum chefe, todos são chefes! Essa é fácil de se cair quando se tem um time super star ou um dream team em determinada tecnologia. Como todos são profissionais de alto valor e experientes, independência total é dada a cada membro do time. No final, ninguém se entende, pois cada membro do tal time resolveu utilizar as práticas e conceitos da corrente de desenvolvimento que mais lhe agrada. No fim, a empresa fica com uma salada de códigos-fonte, provavelmente escritos em várias linguagens de programação, frameworks diferentes, etc. Um pouco de ordem ajuda a manter a sanidade do time.
  • Commits preciosos: alguns times são intruídos a só "comitarem" suas alterações após finalizarem sua tarefa de implementação. Isso funciona bem e evita que código inacabado perturbe o desenvolvimento de outros desenvolvedores devido a anomalias no build. O problema é que algumas pessoas não dividem as tarefas em espaços razoáveis de tempo. O sintoma são commits quinzenais ou mesmo mensais! Indagados sobre a prática, alguns podem responder que fazem isso para não poluir o repositório com commits pequenos. A questão toda é que o próprio desenvolvedor precisa de um sistema de controle de versão para seu desenvolvimento inacabado. Se um sistema de controle de versão distribuído, como o GIT ou Mercurial é usado, pode-se resolver este tipo de problema com branches locais. Com SVN não tem muito jeito... você tem que comitar após testar e garantir que o que foi commitado não quebra o build. Se algo estiver errado, o sistema de controle de versão tem ferramentas para corrigir estas falhas. Além disso, fazer o merge após um mês de desenvolvimento pode ser muito trabalhoso, pois a probabilidade de se ter alterado o mesmo arquivo que outras pessoas é alta, gerando conflitos.
  • Repo killer: quando um membro decide comitar e atualizar apenas partes do repositório, privando os outros membros do time de trabalharem com a mesma versão do código. Essa é inexplicável. Uma variação é o desenvolvedor que escolhe a dedo o que atualizar, esquecendo de incluir novos arquivos e mudanças que nem ele mesmo lembra que fez. Esse problema é uma bomba relógio, pois as diferenças entre os repositórios será evidente cedo ou tarde.
  • Builds locais: poupar o dinheiro de uma máquina de build pode ser a pior economia a fazer em um time de software. Se apenas uma pessoa desenvolve o código, você só saberá que tudo foi comitado ou não no dia que ela sair da empresa. Aí começa a caça aos arquivos perdidos. Outro grande problema é a não documentação do ambiente de desenvolvimento, mas esse problema aparece mais rápido, normalmente quando o HD do desenvolvedor pifa e ele passa uma semana para lembrar tudo que usava (IDE's, bibliotecas, paths, etc). Esse problema também expõe um mais grave: a falta de testes.
  • Ausência de testes: uma das causas de se perder um usuário de seu sistema é transformá-lo em testador. Para isso, você não desenvolve testes automatizados e normalmente não realiza qualquer controle de releases. Isso gera inúmeros problemas durante todo ciclo de desenvolvimento e o único teste acaba sendo feito pelo compilador. Um código que compila está longe de estar livre de erros. Não controlar os erros já reportados pelo usuário é grave. Não corrigi-los é pior e ressuscitar bugs antigos por falta de testes é imperdoável.
  • Zipmania: desenvolvedores param de usar o sistema de controle de versão e começam a trocar Zips com nomes poderosos por IM: sistema20100610_XPO.zip. O vetor de transmissão é um desenvolvedor suicida que resolve fazer a integração na máquina de outro desenvolvedor, antes de fazer os devidos commits, para "evitar conflitos". Fica melhor ainda quando eles começam a criar zips para "congelar" um release e fazer "backup".
  • Variáveis com apenas dois ou três caracteres: essa é muito boa. Um dia você será castigado, tendo que rastrear código em C que usa strtok e variáveis como z, zz e zzz! Fica mais interessante quando esse código é responsável por crashes imprevisíveis no código, do tipo null pointer/segfaults :-D. O pior é que o carrasco pode ter sido você mesmo! É sempre bom comentar o código, principalmente quando o método implementa algo mais complexo que 10 linhas. Mesmo que você não comente, o minimo que pode ser feito é utilizar nomes de variáveis que ainda signifiquem algo dentro de 6 meses ou 2 anos.
  • Gotos: código em C com goto ninguém merece. Tirando raríssimas exceções, usar goto's em C é imperdoável. Fica ainda pior quando os "labels" tem sempre o mesmo nome, em várias funções e o tal goto é escondido por macros. Eu aprendi programar nos anos 80, gotos eram a única saída em Basic, mas já eram abominados em C e Pascal há bastante tempo e mesmo antes (Dijkstra, 1968). Para programadores modernos, um goto é simplesmente um atentado a programação estruturada.
  • A praga do log: aqui os sintomas são diferentes dependendo da linguagem. Em C/C++ você pode usar o pré-processador para esconder seu log de DEBUG ou fazer a coisa certa e usar um framework descente. Em Java, você tem os loggers da vida. O pior que você pode fazer é usar múltiplos System.outs ou printfs para fazer o log na mão. A praga do log é que mesmo usando um framework, você acaba espalhando linhas de log para tudo e usando apenas dois ou três níveis de log. No final, você tem arquivos de log gigantescos que chegam mesmo a retardar a execução do programa. Eu já procurei causas de lentidão em sistemas Java para descobrir que tínhamos deixado o log das bibliotecas em C ligado! Simplesmente, cada linha do log abria, escrevia, dava um flush e fechava o arquivo na mesma linha, claro, escondendo tudo isso numa macro! C hoje em dia é tão rápido que você pode fazer barbaridades, mas quando você loga deste jeito dentro de um XML parser... a coisa explode.
  • Ignorar mensagens de erro do compilador: essa aqui é um prelúdio para o sofrimento. Se no gcc seu código não compila com -Wall ou se você é o rei dos pragmas do Visual C++, lembre que se estas mensagens fossem realmente pouco importantes, elas não seriam geradas pelo compilador! No Java, usa-se o -Xlint para ter warnings mais precisos. O importante é que seu build seja limpo! Isso faz com que qualquer erro seja rapidamente notado. O mesmo para os logs. Se tudo é mostrado na tela, você simplesmente pára de olhar, pois se acostuma a ver lixo ou mensagens que não são interessantes.
  • Localização tabajara: ao trabalhar com código para múltiplas línguas, melhor não improvisar. Java resolve este tipo de problema muito bem e o Python na sua versão 3 melhorou bastante. Misturar strings em páginas de código diferentes é fatal! Fazer localização com ifs no código é pior ainda. Até a Microsoft tenta forçar o uso de UNICODE no Visual C++. O pior é ignorar diferenças de codificação e mesmo de tratamento de mensagens. Além da ordem das palavras, línguas diferentes tem critérios também diferentes para ordenação de caracteres, plural e letras maiúsculas, por exemplo. 
  • Build scripts escritos em Perl e batches: quem ainda trabalha com Perl merece todo castigo :-D O problema são pessoas que não utilizam Perl e que tentam fazer scripts de build em Perl. O mais legal é quando o build é multiplataforma é os tais scripts geram código em C ou C#, sem nada dizer. Para melhorar a festa, pode-se utilizar múltiplos scripts (multiplicados pelo padrão: copy and paste, rename). Agora a cereja do sorvete é fazer isso tudo usando Windows ou Cygwin.
  • Babel: por que utilizar apenas uma linguagem de programação? Seu projeto pode ter muitas, você pode até deixar seus programadores escolherem a linguagem de programação mais adaptada a cada tarefa e depois reunir isso tudo via SOAP. Usar Perl com qualquer outra coisa é trabalhar contra a empresa. C/C++ e Java, tudo bem, um pouco de Python ok. Mas se seu código é realmente escrito partes em Basic, partes em C/C++/C# e você resolveu colocar a parte concorrente em F# é porque você já vive o sonho do .Net. O mesmo acontece em Java: Jython ou JRuby, Groovy e Scala. Você pode misturar como quiser, mas a manutenção do código vai ser um pesadelo. Quanto mais linguagens você utilizar, mais difícil será encontrar alguém capaz de trabalhar com todas estas linguagens. Lembre-se que toda linguagem evolui, forçando um esforço arqueológico para entender o que a versão X fazia com a versão Z. Melhor evitar ou pedir aprovação do alto conselho Klingon antes de começar a construir sua torre. E por que apenas uma torre? Você pode desenvolver seu código para múltiplas plataformas, para adicionar um pouco de tempero. Mesmo com Java, faz-se milagre: J2SE, Java ME CDC e Java ME CLDC... a festa! Com C# você pode brincar com o compact framework e por que não com Mono?
  • Demos: demo é coisa do cão :-D Quem trabalha comigo ouve essa todo dia. O problema de "demos" que elas são normalmente escritas para rodar apenas uma vez e num curto espaço de tempo. O que leva ao próximo problema. Uma demo é diferente de um protótipo. Um protótipo normalmente é criado para resolver um problema específico ou para demonstrar como os analistas entenderam o problema, um instrumento para refinar e melhorar programas. Uma demo é normalmente criada para demonstrar o domínio de uma tecnologia, é um PPT executável e com código fonte! Normalmente elas resistem a aposentadoria e tem a tendência a evoluir. O ambiente propício para proliferação é a véspera de exposições e eventos.
  • Códigos escritos para rodarem apenas uma vez: não acredite nisso. Uma vez que um programa é escrito, o universo conspira para que ele seja mantido por muito tempo. Quase nunca você vai escrever código para rodar apenas uma vez. Se for o caso, tenha certeza de apagar o bicho logo depois da primeira execução, só para garantir.
  • XML Doom: alguém resolve que tudo deve ser escrito em XML. Eu já via até métodos que recebem os seus parâmetros no formato mágico que começa com X. O mais interessante do XML é que ele foi criado para facilitar o intercâmbio de informações e também ser legível tanto por computadores quanto por seres humanos. A ideia era poder ter um formato simples, baseado em UTF, ou pelo menos ciente dos inúmeros problemas de internacionalização e de representação de dados binários em formato texto. A coisa começou a desandar quando começamos a escrever arquivos XML na mão, para facilitar o parsing de arquivos de configuração. O XML que deveria ser gerado pelo computador, acabou sendo gerado manualmente. Alguns conseguem ter a sorte de ter editores de textos adaptados e mesmo ferramentas que ajudam na árdua tarefa de criação destes monstros. Uma ideia muito boa que acabou sendo abusada. XML não deve ser usado pra tudo.
  • Copy and Paste hell: essa é a pior de todas. Se você copia e cola o mesmo código várias vezes, algo está errado. Ou você não usa os recursos de template de seu IDE (aqueles que transformam syso em System.out.println()) ou você está realmente perdido. Grave mesmo é se você copia grandes partes de código, criando métodos gigantes. Programas criados com alta participação de copy and paste demonstram um problema grave de modularização e normalmente não isolam conceitos adequadamente. Lembre-se que cada código copiado e colado terá os mesmos problemas do código de origem, se você tiver sorte, fazendo com que alterações e modificações tenham que ser propagadas para todas as cópias. É realmente um desafio a sua memória. Sempre se esquece um ou dois... e lá estarão os problemas. Duro mesmo é corrigir o mesmo problema várias vezes. Além disso o tamanho do programa cresce assustadoramente rápido. Depois de ver código em javascript com 10000 linhas por arquivo você fica com medo desta síndrome.

Parece comédia, mas tudo isso é real. Profissão alguma é perfeita ou sem dificuldades, a diferença em informática é que nós criamos e retiramos os obstáculos no nosso caminho :-). Normalmente misturando novas soluções com antigos problemas numa velocidade fantástica.

quarta-feira, 9 de junho de 2010

Lendo livros em formato PDF

Um problema que sempre tive com livros em formato PDF é marcar o ponto onde parei de ler para depois continuar. Nos últimos anos, livros em formato PDF se popularizaram e eu consumo principalmente os livros da Pragmatic Programmers neste formato. Um simples documento PDF de até 5 ou 10 páginas pode ser lido inteiramente em poucos minutos, mas um livro de 500 ou 600 páginas não pode ser consumido de uma só vez. É nesses casos que um leitor adaptado a esta tarefa é necessário.

No Mac eu vinha usando o Skim, um leitor de PDF que permite fazer anotações e outras modificações no PDF que só o Acrobat da Adobe permitiriam, a diferença é que o Skim é open souce. Com o Skim, pode-se utilizar uma barra de leitura que ajuda muito na hora de ler, principalmente para quem pula linhas como eu :-D

Mas como todo grande aplicativo de Mac, o Skim não tem versão para Ruindows e também não grava a última página de cada PDF... tornando a leitura de livros difícil. Para contornar este tipo de problema, eu acabei por utilizar anotações no meu telefone para registrar a página que parei em cada livro, verdadeiramente low tech.

Semana passada eu encontrei o Adode Digital Editions, gratuito e multiplataforma, desenvolvido pela mesma companhia que inventou o formato PDF. Ele foi criado para permitir acesso aos livros digitais da plataforma e-book da Adobe, mas também pode ser utilizado para ler livros já baixados em formato PDF ou ePub. A grande vantagem é poder utilizar o recurso de biblioteca, permitindo juntar os PDFs espalhados pelo disco rígido em uma só interface, organizar estes PDFs em pastas e marcar onde paramos de ler facilmente. No Digital Editions, quando reabro um PDF ele está exatamente na mesma posição que deixei da última vez. A interface é bem limpa e facilita a leitura, tendo apenas os controles básicos de navegação e visualização do PDF e opcionalmente o conteúdo a esquerda.

Ainda não experimentei em vários micros, mas como o recurso de criar uma conta na Adobe, acredito que a sincronização seja possível. Outros recursos parecem bem interessantes, como a possibilidade de emprestar livros. Por enquanto, a funcionalidade de marcar o último ponto de leitura e o tamanho de apenas 19Mb x 195Mb do Acrobat Reader para Mac já são bem interessantes.