Living in the programming world

Otimizando com Javascript

Inicialmente, o nome desse post era pra ser: “otimizar ou escalar?”, mas acabei optando por este outro nome. Afinal, a postagem é sobre como foi otimizado, então…

Há algum tempo, aqui em meu trabalho, sofríamos com um sistema meio problemático: o sistema em questão é um sistema montado para que alunos possam escolher disciplinas, e é feito em duas fases. Nosso problema específico era com a segunda fase: um aluno só pode escolher uma disciplina desde que ela possua vagas, e como há certas disciplinas que muitas pessoas querem, isso vira uma corrida contra o tempo: praticamente metade da universidade acessando o sistema ao mesmo tempo, para conseguir sua vaga, e o sistema demorando muito tempo para completar cada requisição, enfileirando requisições, e um tempo absurdo para atender cada uma…

Enfim, foi jogado mais poder de processamento, mas para cada um processador que acrescentávamos, entravam mais quinheitos alunos, e cerca de cem disciplinas. Claramente, não haveria load-balancer que aguentasse, nem máquina que pudesse aceitar. Estudamos uma base não-relacional, diversas soluções, até chegar em uma: processar a página no cliente.
(more…)

By Maurício Szabo, ago

Update: o que estou estudando?

Como faz tempo que não posto nada no blog (falta tempo), resolvi fazer este post meio que para iluminar um pouco o que tenho estudado ultimamente.

Comecei a aprender Scala. Na verdade, peguei esse tempo para estudar linguagens interessantes, que há tempos quero estudar como Scala, Haskell e Lisp. Criei um repositório de testes para brincar com essas linguagens no meu github: https://github.com/mauricioszabo/learning. Futuramente, farei posts sobre Scala também, que é uma linguagem interessante para substituir Java.

Comecei também a estudar desenvolvimento para Android. Instalei o emulador, fiz uns “hello, worlds” com Scala, Java e JRuby (Ruboto), o suficiente pra descobrir que rodar algo em Ruboto é inviável de tão lento…
(more…)

By Maurício Szabo, ago

A Humanidade de um Cientista

Esses dias, estava lendo um blog de um professor daqui da UFABC. Um professor que, conforme a noticia oficial, “faleceu em circunstâncias trágicas”. Não o conhecia, pessoalmente, mas gostaria mesmo de tê-lo conhecido. Alguém que possuía uma inteligência acima do normal, alguém que via e sentia acima de sua inteligência, inconformado com o mundo, e pelas suas postagens, inconformado consigo mesmo.

Alguém que juntou algumas cadeiras, no décimo primeiro andar do prédio, e de lá se atirou.

Não quero discorrer sobre o quão certo ou errado isso é. Religiões o culpariam, alguns apontam o dedo e dizem “suicida!”, mas a verdade é que: 1) ninguém sabe o que ele estava passando (nem mesmo eu, só posso deduzir brevemente pelo seu diário abandonado na internet), e 2) eu acredito, sinceramente, que cada um de nós é dono de sua própria vida, por mais que algumas religiões insistam em contrário, por mais que a própria lei brasileira criminalize o suicídio. Sua escolha foi errada? Sim, pelo lugar escolhido. Acredito que muitas pessoas devam ter sido obrigadas a ver algo que não estavam preparadas, mas também, vejo que isso expõe certas verdades ocultas.

Em primeiro lugar, por que escolher a universidade, seu local de trabalho? Por que escolher logo a entrada do prédio, um lugar aonde todos veriam sua decisão, e ao mesmo tempo ter pensado em um lugar aonde, com toda a certeza, ele não cairia sobre ninguém?

Sua morte foi noticiada como “circunstâncias trágicas”. Claro, suicídios normalmente incitam mais suicídios quando são noticiados como tal. Não caberia uma discussão maior sobre o assunto? Por que ocultar um suicídio com medo de uma “epidemia”, ao invés de tentar evitar que as pessoas tenham essa vontade? Se é sabido que isso gera epidemia, por que não estudar e tentar minimizar os motivos que levam pessoas a quererem tirar sua própria vida? Ou será que isso não é, digamos, interessante para a “sociedade”? Eles realmente não acham que criminalizar o suicídio, ou dizer “quem se mata vai pro inferno” vai evitar esse tipo de incidente, não é?
(more…)

By Maurício Szabo, ago

Como eu Entendo BDD

Test Driven Development, ou Behaviour Driven Development… duas “buzzwords” que, só de serem pronunciadas, trazem milhares de sentimentos. Porém, isso não mostra uma cruel realidade:

Poucas pessoas concordam com o que é, de fato, “teste de software”.

Em uma apresentação que fui, no AgileBrazil, com cerca de 150 pessoas na platéia, o apresentador lançou a pergunta: “o que é teste de software para você?”. O experimento era escrever em um papel sua resposta, e trocar com a pessoa do lado. Estranhamente, apenas 5 pessoas, na platéia toda, receberam um papel com uma explicação que batia com a sua.

Então, acho que seria interessante citar o que eu entendo por Teste de Software, e porque eu considero que pratico “Behaviour Driven Development”.
(more…)

By Maurício Szabo, ago

Retrospectiva 2010

Demorei um pouco mais do que eu gostaria para escrever esse post mas, vamos lá: retrospectiva do ano todo. Este será um post bem pessoal, mas como sempre, nem só de código vive uma pessoa: junto, há uma turbulência de sentimentos que acabam influenciando a vida toda e a de quem estiver próximo.

Em 2010, tudo indicou que seria um péssimo ano. E, na maior parte, ele foi realmente muito ruim, mas com todas essas coisas ruins, algo de bom surgiu no meio das frustrações.

Foi um ano de rubys e aprendizados. Logo no começo do ano, perdi um cargo de chefia que significava muito mais do que eu imaginava, e isso me inspirou a escrever artigos e palestras. Me inscrevi no AgileBrazil, aonde fui palestrante e acredito que deu para mostrar muita coisa boa que foi feita em meu trabalho, muito embora esse trabalho não seja reconhecido pelos próprios gestores. Logo depois, participei pela primeira vez do FISL, também como palestrante. Pouco antes, ingressei no Grupo de Usuários de Ruby, o GURU-SP, e para minha surpresa fui reconhecido no FISL, e pouco tempo depois no RubyConfBR (por sinal, um dos melhores eventos que já fui).

Em todos esses eventos, mais do que Ruby, acabei aprendendo outras coisas bem interessantes. Me meti a usar CouchDB em alguns experimentos caseiros, comecei a me aventurar bem mais com JavaScript e até a gostar da linguagem, e aprendi um pouco mais sobre as técnicas de desenvolvimento de sistemas complexos, embora infelizmente eu não tenha tido oportunidade ainda para aplicar os conhecimentos em um sistema realmente complexo. Como certas coisas insistem em não mudar, mesmo estudando muito mais do que eu imaginava, nesse ano, ainda assim não consigo gostar de Java, mas é a vida…
(more…)

By Maurício Szabo, ago

Métodos privados semelhantes a Java/C++ em Ruby

Fazia um tempo que eu não postava uma das bizarrices em Ruby, então vamos lá: esses dias, no grupo de usuários de Ruby, surgiu uma discussão muito boa sobre métodos privados e alto acoplamento. A idéia é mais ou menos assim: em Java (ou C++), ao definir um método público que chama um método privado, se você reimplementar aquele método privado, os métodos públicos herdados não são afetados. Um exemplo vale mais que mil palavras, então:

#include <stdio.h>

class Example {
    public:
    void imprimir() {
        hello();
    }

    private:
    void hello() {
        printf("Hello, world!\n");
    }
};

class Ex2: public Example {
    private:
    void hello() {
        printf("Hello, from Ex2\n");
    }
};

int main(void) {
    Ex2 e;
    e.imprimir(); //Essa linha imprime "Hello, world!"
}

Já no código Ruby equivalente:

class Example 
  def imprimir()
    hello
  end

  private
  def hello
    puts "Hello, world!"
  end
end

class Ex2 < Example 
  private
  def hello
    puts "Hello, from Ex2"
  end
end

Ex2.new.imprimir #Imprime "Hello, from Ex2"

Ou seja, reimplementar métodos privados numa subclasse pode quebrar métodos da superclasse. Embora eu considere isso uma peculiaridade da linguagem e não como um problema de acoplamento, implementação falha, ou qualquer coisa (e até, mais pra frente, pretendo escrever um post sobre o assunto de diferenças entre linguagens de programação além da sintaxe), a discussão inteira me deu uma idéia: como implementar esse comportamento em Ruby?
(more…)

By Maurício Szabo, ago

SOLID e SQL

Para os que não conhecem, o princípio SOLID é uma “sigla de siglas”, uma tentativa de formalizar códigos limpos, flexíveis e funcionais principalmente para linguagens orientadas a objeto. Os princípios são Single Responsibility Principle, Open-Closed Principle, Liskov Substitution Principle, Interface Segregation Principle e Dependency Inversion Principle. Sendo bem sucinto:

  • SRP indica que todo objeto deve ter apenas uma responsabilidade. Ou seja, fazer uma classe para atender apenas uma função específica.
  • OCP indica que toda classe deve ser aberta para adição de novas funcionalidades, mas fechada para modificação. Ou seja, quando for preciso adicionar mais funcionalidades, isso deve ser feito apenas adicionando novos métodos, sem precisar alterar os que já existem.
  • LSP indica que deve ser possível substituir um objeto por seus filhos, na herança, sem dar problema. Na prática, significa que um objeto filho altera a forma como o objeto pai funciona, extendendo ou não suas funcionalidades, mas nunca alterando o comportamento geral
  • ISP indica que todo código deve organizado de forma que jamais seja necessário implementar métodos que não são utilizados. A idéia é melhor explicada (com exemplos) neste post.
  • DIP indica uma necessidade de depender de classes abstratas, não de classes concretas. Ou seja, ao invés de, em um código, receber num método uma classe concreta, receber uma classe abstrata e, quando o método for chamado, passar uma classe concreta

Ok, e aonde o SQL entra nisso? Ele não é orientado a objeto, não é “turing-complete”, é apenas uma linguagem de busca num banco de dados, certo? E sim, eu tou falando de SQL, não de PL/SQL ou qualquer coisa semelhante. A explicação é muito simples: Clean Code
(more…)

By Maurício Szabo, ago

Closures, Functions e Programação Funcional em Javascript

Estes dias, tive que fazer um código que achei que seria muito complicado, e que deveria rodar num browser. A idéia é que, dependendo do que foi digitado em uma determinada caixa de texto, um pedaço de uma página deveria mudar. Até aí, tudo bem, o problema é que o pedaço que deveria mudar deveria agrupar informações de outras caixas de texto, e outras regras confusas. Achei uma solução muito simples e prática, e gostaria de dividí-la. Mas antes, vamos simplificar o escopo:

Imagine que há uma página, no qual há um botão “adicionar”. Ao clicar nele, ele adiciona um “select” (sexo) e uma caixa de texto com observações ou qualquer outra coisa. Podem ser adicionados tantos elementos como se achar necessário. Para cada elemento alterado, deve ser exibido um sumário na tela de baixo (observações), digamos, concatenando o sexo e as observações. A parte difícil é: quando qualquer elemento for mudado, APENAS o sumário relativo àquele conjunto de elementos (sexo e observação) deve ser alterado, e também, quando eu estiver editando as observações (ou o sexo), o sumário deve ficar em negrito. Para simplificar (e rodar em vários browser) usarei a biblioteca Javascript chamada Prototype (não usarei o JQuery porque seria jogar uma bomba numa mosca), e a idéia é escrever apenas o código relativo às edições (porque é isso que pega). Portanto, para quem quiser, basta pegar o gist do Github http://gist.github.com/658668 para ter um esqueleto do programa (basta abrir o .html em qualquer browser).
(more…)

By Maurício Szabo, ago

Monkey-Patch seguro, em Javascript

Continuando os estudos com Javascript, diversas coisas interessantes, que pareciam acessíveis apenas aos programadores de Ruby, Perl e outras linguagens mais flexíveis podem ser feitas também na linguagem. O problema é que, normalmente, é difícil de usar isso em bibliotecas que já existem, principalmente porque a maioria dos códigos em Javascript ou não seguem boas-práticas ou simplesmente são escritos de forma diferente do que vou apresentar aqui, porém vale pela dica. Um exemplo bem simples, pensando na seguinte API:

objeto = {
  valor: 10,
  incrementar: function(v) { 
    if(!v) v = 1;
    valor += v;
  },
  raizQuadrada: function() {
    Math.sqrt(incrementar(4));
  }
}

Para implementá-la, em Javascript, há várias formas. Simulando o comportamento que eu fiz no post passado, é possível usar o seguinte formato:
(more…)

By Maurício Szabo, ago

Estudos com Javascript

Recentemente, comprei o livro Javascript – the Good Parts, do Douglas Crockford. A principal motivação, não vou negar, foi o node.js (e o fato que muitas pessoas na net têm falado de Javascript como uma das mais “novas” maravilhas. Mas isso fica pra outro post). O livro, embora tenha uma série de problemas (e o principal é a ausência de exemplos claros, além de dar pouca ênfase ao “Javascript way”, na minha opinião) é muito bom e traz algumas definições no mínimo diferentes sobre Javascript.

Basicamente, o que é Javascript? Javascript é orientado a objeto? Javascript é funcional? Javascript suporta classes, suporta….?

Para começar, Javascript é uma linguagem de programação com sintaxe semelhante a C++, dinâmica, com tipagem absurdamente fraca, pseudo-orientada a objetos, orientada a protótipos e funcional. Wow… um de cada vez.
(more…)

By Maurício Szabo, ago