Marcio Andrey Oliveira

Some software related books I've read

noreply@blogger.com (Marcio Andrey Oliveira) — Fri, 10 Jul 2009 03:05:00 +0000

Shelfari: Book reviews on your book blog

Do you really know C

noreply@blogger.com (Marcio Andrey Oliveira) — Tue, 23 Jun 2009 20:29:00 +0000

I don't like to write about C because Wanderley, a friend of mine, is much more able to talk about it, but I think I must report what happened to me these days.

After some time developing with a programming language we get so used to it that we start thinking we are the master on it.

But usually the opposite happens: we forget some basic and subtle aspects of the language.

A couple of days ago I wrote the C command bellow:

printf("x position = %d (again??)", 7);

and to my surprise it was printed

x position = 7 (again ]

Why didn't the application printed

x position = 7 (again ??)

I thought "Visual Studio (2005) is a crap!".

Some taboo words latter and I realized what the problem was.

I remembered C has a feature named trigraph. In other words, C replaces all special sequences of three characters by their single-character equivalent.

The following are the nine trigraph sequences that C recognizes.

Trigraph    Equivalent
??=         #
??/         \
??'         ^
??(         [
??)         ]
??!         |
??<         {
??>         }
??-         ~

Why do C has trigraphs? To let us for writing source code when the keyboard being used does not support any of these nine characters.

I compiled the program using gcc and it gives me the following warning

warning: trigraph ??) ignored, use -trigraphs to enable

This means that on gcc we must explicitly request to it to enable trigraphs. The output presented after running the program was

x position = 7 (again ??)

Since 1994 the C standard (C99), supplies digraphs as more readable alternatives to six of the trigraphs. They are:

Digraph     Equivalent
<:      [
:>      ]
<%      {
%>      }
%:      #
%:%:    ##

I must not be so proud of myself because eventually something (like this) remembers me that I am already a newbie and a wanna-be.

Oh, and at this time Visual Studio was unfairly blamed. Sorry ;)

Você conhece mesmo o C

noreply@blogger.com (Marcio Andrey Oliveira) — Tue, 23 Jun 2009 17:26:00 +0000

Eu não gosto de escrever sobre C, porque o meu amigo Wanderley é muito mais abilitado para falar sobre o assunto (além de escrever de um modo bem divertido), mas eu acho que eu devo falar sobre o que aconteceu comigo estes dias.

Após algum tempo desenvolvendo com uma linguagem de programação nós nos acostumamos a ela e começamos a achar que a dominamos.

Mas, geralmente, o que ocorre é o contrário: nós esquecemos alguns aspectos mais básicos e sutis da linguagem.

Alguns dias atrás eu escrevi o seguinte trecho de código em C:

printf("x position = %d (again??)", 7);

e, para minha surpresa, foi impresso

x position = 7 (again ]

Por que o programa não imprimiu

x position = 7 (again ??)

Eu pensei "esse Visual Studio é uma merda!". Alguns palavrões depois e eu percebi qual era o problema.

Eu lembrei que o C tem um recurso chamado trígrafo. Em outras palavras, o C substitui todas as ocorrências de sequências especiais de três caracteres por seus equivalentes de caracter único.

A seguir temos as nove sequências de trígrafos que o C reconhece.

Trigraph     Equivalent
??=          #
??/          \
??'          ^
??(          [
??)          ]
??!          |
??<          {
??>          }
??-          ~

E por que o C suporta trígrafos? Para nos permitir escrever códigos fonte quando o teclado que estiver sendo usado não possuir suporte aos nove caracteres acima.

Eu compilei o programa usando o gcc e obtive o seguinte warning

warning: trigraph ??) ignored, use -trigraphs to enable

Ou seja, eu devo explicitamente habilitar o uso de trígrafos no gcc. A saída do programa após executá-lo foi

x position = 7 (again ??)

Desde 1994 o padrão do C (C99) fornece suporte a dígrafos como uma alternativa mais legível a seis dos nove trígrafos. São eles:

Digraph  Equivalent
<:                    [
:>                    ]
<%                  {
%>                  }
%:                   #
%:%:              ##

Eu não devo me sentir tão orgulhoso de mim, porque sempre termina acontecendo algo desse tipo para me lembrar que eu ainda tenho muito para aprender.

Ah, e dessa vez o Visual Studio foi xingado injustamente. Desculpem-me ;)

How to boot Ubuntu in console mode (no X)

noreply@blogger.com (Marcio Andrey Oliveira) — Tue, 26 May 2009 18:24:00 +0000

Despite the fact that graphical user interface is easier to daily work, I really prefer command line interface.

I tried to disable graphical startup on Ubuntu by editing inittab file, but what a surprise when I did not find it.

Where is it? After some googling I found out that to always boot in console mode you must execute this command:

sudo update-rc.d -f gdm remove

Every time you wish you can invoke Gnome from command line by typing

startx <ENTER>

How to declare 64 bits in Visual Studio 6

noreply@blogger.com (Marcio Andrey Oliveira) — Fri, 22 May 2009 01:49:00 +0000

Did you ever needed to declare a 64 bits integer using Visual Studio 6?

On newer versions of Visual Studio and on gcc you can use the ll to tell the compiler that the value is 64 bits wide. But Visual Studio 6 does not understand it.

How do you do? You must use the keyword

__int64.

I discovered it because a project I wrote using Visual Studio 2005 that must be compiled using Visual Studio 6.

Below you can see a sample code that compiles both in VS 6 and 2005.


#include 
#include "stdafx.h"
#include 

int main(int argc, char* argv[])
{
  __int64 i = 0;

  printf("Hello World! %08x %08x\n", i);

  #ifdef _MSC_VER
      #if _MSC_VER <= 1200
         // Visual Studio 6 or lower do not accept ll as 64 bits constants.
         #define __IGNORE_LL_MODIFIER_MS         
         #endif // _MSC_VER     
      #endif // _MSC_VER

  #ifdef __IGNORE_LL_MODIFIER_MS
      i = ((__int64)0x1234567890123456);
  #else
      i = 0x1234567890123456ll;
  #endif

  printf("Hello World! %08x %08x\n", i);
  getchar();
  return 0;
}

I really hope this piece of information will be helpful to someone.

Get your own bazaar hosting service for free

noreply@blogger.com (Marcio Andrey Oliveira) — Mon, 18 May 2009 16:58:00 +0000

I was looking for a free bazaar hosting service that let me use it with my private projects. Unfortunately I was not able to find anyone.

This week I came across DropBox. DropBox is a site that let you share files between computers (and between people if you wish to). The basic plan give you 2GB for free!

DropBox interface is pretty easy to use. One folder (usually named DropBox) will be used to share your files.

You put a file into the folder and it will be available into any computer you log in. have you changed the file? DropBox will update it.

Don't you want the file anymore? Delete it from your Dropbox folder and it will be delete from other computers too (as soon as you get logged into them). DropBox will keep your files synchronized. You don't have to worry about it.

So, I decided to use it as a bazaar repository. I created a folder named bzr.d under DropBox. All files I want to keep under source control are inside this folder.

Now I have my own bazaar hosting for free. And know what? You can share your bazaar repository (bzr.d in my case) with some friends and all of you will be able to develop the same project.

You can even have many repositories at the same time (since they don't occupy more than 2GB).

Do you need more space? DropBox has two paid plans (50GB and 100GB).

And you can use it as a hosting for git and mercurial too.

I think it's worth a try.

GMouseTool on the fourth annualSourceForge.net Community Choice Awards

noreply@blogger.com (Marcio Andrey Oliveira) — Thu, 14 May 2009 02:11:00 +0000

I've nominated my project for the fourth SourceForge.net Community Choice Awards.

It is the election of the best programs of the year that have been choosed by users.

I am not under any illusion that I will win. GMouseTool is a very tiny project. And, as far as I know, there are only two GMouseTool users: me and another person named Ryan Reif.

It it is just for fun. You can vote for GMouseTool. Click into the image below. You must supply a valid e-mail. Then you confirm your nomination using the link Sourceforge will provide.

GMouseTool already have a vote. Now I need you vote for it ;)

GMouseTool no quarto SourceForge.net Community Choice Awards

noreply@blogger.com (Marcio Andrey Oliveira) — Thu, 14 May 2009 01:45:00 +0000

Acabei de inscrever o meu projeto no quarto SourceForge.net Community Choice Awards.

É a eleição dos melhores programas do ano feita por voto direto dos usuários.

Não tenho a menor ilusão que vou ganhar alguma coisa. Além do GMouseTool ser um projeto muito pequeno, até onde eu sei, ele só tem dois usuário: eu e outra pessoa chamada Ryan Reif.

Mas vale a diversão. Se quiseres votar no GMouseTool, é só clicar na imagem abaixo e fornecer um e-mail válido. Aí o SourceForge vai te enviar um link que tu clicas para confirmar o voto.

Um voto o GMouseTool já tem. Agora só falta o teu voto. ;)

Vim usando o corretor ortográfico Vero

noreply@blogger.com (Marcio Andrey Oliveira) — Tue, 05 May 2009 20:15:00 +0000

O pessoal do BrOffice tem um verificador ortográfico chamado Vero, que já está adaptado ao novo acordo ortográfico.

Neste artigo vou mostrar como fazer o Vim utilizar o dicionário implementado no Vero.

1 - Baixe o corretor ortográfico no site do BrOffice: http://www.broffice.org/verortografico/baixar.

Eu baixei o arquivo Vero_pt_BR_V204AOC.oxt (a última versão no momento em que escrevo este artigo).

2 - Descompacte o arquivo (apesar da extensão .oxt, ele não passa de um arquivo zip). Será criada uma estrutura de diretórios semelhante a mostrada na figura 1.

Figura 1 - Estrutura de diretórios criada após descompactação

3 - Entre na pasta Dictionaries (ver figura 2), abra o Vim (ou o GVim) e, no modo de comando, digite:

:mkspell pt pt_BR <ENTER>

Figura 2 - Diretório de onde deve-se executar os comandos

O Vim irá processar os arquivos pt_BR.aff e pt_BR.dic e irá gerar um terceiro arquivo chamado pt.utf-8.spl.

4 - Crie a pasta ~/.vim/spell, se a mesma ainda não existir.

5 - Copie o arquivo pt.utf-8.spl para ~/.vim/spell ou $VIMRUNTIME/spell.

Agora Tu tens duas opções para utilizar a verificação ortográfica:

1. tu podes habilitá-la quando necessário, digitando no modo de comando:

:set spell <ENTER>
:set spelllang=pt <ENTER>

2. Tu configuras o arquivo .vimrc para que a correção esteja habilitada o tempo todo, acrescentando as linhas abaixo

e a desabilita quando não quiseres utilizá-la, digitando no modo de comando

:set nospell

Para reabilitar a verificação ortográfica, basta digitar no modo de comando

:set spell <ENTER>

Pronto. O Vim já está apto a usar o dicionário com a nova ortografia que emprestamos do Vero / BrOffice.

Outra coisa que podes fazer é utilizar o dicionário como fonte das palavras sugeridas no autocompletar.

Podes digitar no modo de comando

set complete+=kspell <ENTER>

ou incluí-la no .vimrc.

13 passos simples para termos o Django no Google App Engineprot

noreply@blogger.com (Marcio Andrey Oliveira) — Wed, 15 Apr 2009 17:29:00 +0000

Este sensacional tutorial é uma tradução do artigo Django on Google App Engine in 13 simple steps, escrito por Thomas Brox Røst.

Neste tutorial eu mostrarei como ter uma aplicação simples com acesso a banco de dados usando Django e rodando no Google App Engine. Assumirei que você tem alguma familiaridade com o Django.

Passo 1: Registre um nome de aplicativo e instale o kit de desenvolvimento seguindo as instruções do site.

Passo 2: Crie um diretório para o seu aplicativo - Para este tutorial meu aplicativo chama-se mashname:

tmp$ mkdir mashname
tmp$ cd mashname

Passo 3: Adicione um arquivo chamado main.py no seu novo diretório:

# main.py

import os, sys
os.environ["DJANGO_SETTINGS_MODULE"] = "mashname.settings"
sys.path.append("/home/brox/tmp/mashname")

# Google App Engine imports.
from google.appengine.ext.webapp import util

# Force Django to reload its settings.
from django.conf import settings
settings._target = None

import django.core.handlers.wsgi
import django.core.signals
import django.db
import django.dispatch.dispatcher

# Log errors.
#django.dispatch.dispatcher.connect(
#   log_exception, django.core.signals.got_request_exception)

# Unregister the rollback event handler.
django.dispatch.dispatcher.disconnect(
django.db._rollback_on_exception,
django.core.signals.got_request_exception)

def main():
 # Create a Django application for WSGI.
 application = django.core.handlers.wsgi.WSGIHandler()

 # Run the WSGI CGI handler with that application.
 util.run_wsgi_app(application)

if __name__ == "__main__":
main()

Este é basicamente o mesmo arquivo sugerido, exceto pelo caminho do Python que eu tive que configurar para poder fazer os testes localmente. Eu também tive que configurar a variável DJANGO_SETTINGS_MODULE - pode ser que este passo seja desnecessário quando o aplicativo estiver executando no App Engine. Eu tive que desabilitar o log de erros, os quais eu não consegui fazer funcionar.

Passo 4: Adicione um arquivo chamado app.yaml ao mesmo diretório com o conteúdo abaixo:

application: mashname
version: 1
runtime: python
api_version: 1

handlers:
- url: /.*
script: main.py

Assegure-se de usar o nome correto do aplicativo.

Passo 5: Do seu diretório mashname, crie um novo projeto do Django:

tmp/mashname$ django-admin.py startproject mashname

(Estou assumindo que o seu diretório do Django está configurado e funcionando como deveria.)

Passo 6: Agora você deveria poder testar seu aplicativo:

tmp/mashname$ cd ..
tmp$ dev_appserver.py mashname
INFO     2008-04-08 19:08:10,023 appcfg.py] Checking for updates to the SDK.
INFO     2008-04-08 19:08:10,384 appcfg.py] The SDK is up to date.
INFO     2008-04-08 19:08:10,404 dev_appserver_main.py] Running application mash
name on port 8080: http://localhost:8080

Aponte o seu browser para o endereço http://127.0.0.1:8080/ e você deverá ver a mensagem padrão do Django "It worked!".

Passo 7: Crie um aplicativo Django dentro do projeto:

tmp$ cd mashname
tmp/mashname$ python mashname/manage.py startapp main

Passo 8: Agora é hora de adicionarmos um modelo. Nós criaremos um aplicativo simples que loga todos os visitantes em uma base de dados e exibe seus endereços IP. Edite o arquivo ~/mashname/mashname/main/models.py para que ele se pareça com isso:

# models.py

from google.appengine.ext import db

class Visitor(db.Model):
  ip = db.StringProperty()
  added_on = db.DateTimeProperty(auto_now_add=True)

Não há necessidade de sincronizarmos o banco de dados uma vez que não estaremos usando os modelos do próprio Django.

Passo 9: Agora nós criaremos uma view que é responsável tanto por adicionar os dados ao modelo Visitor quanto por mostrar os visitantes anteriores. Edite o arquivo views.py (no mesmo diretório em que está o arquivo models.py) de modo que ele faça o que queremos:

# views.py

from django.http import HttpResponse

from mashname.main.models import Visitor

def main(request):
  visitor = Visitor()
  visitor.ip = request.META["REMOTE_ADDR"]
  visitor.put()

  result = ""
  visitors = Visitor.all()
  visitors.order("-added_on")

  for visitor in visitors.fetch(limit=40):
      result += visitor.ip + u" visited on " + unicode(visitor.added_on) + u""

  return HttpResponse(result)

Passo 10: Finalmente, faça com que o seu arquivo urls.py aponte para a view:

# urls.py

from django.conf.urls.defaults import *

urlpatterns = patterns("",
  (r"^$", "mashname.main.views.main"),
)

Passo 11: Teste o seu aplicativo (do mesmo modo que foi feito no passo 6) e tudo deveria funcionar perfeitamente. A cada vez que a página for recarregada uma nova entrada será adicionada ao modelo Visitor model e será exibido na view.

Passo 12: Faça o upload do seu aplicativo para o Google App Engine:

tmp$ appcfg.py update mashname

Na primeira vez em que o upload for feito, você terá que informar seu e-mail e sua senha do google.

Passo 13: Divirta-se! Para ver o resultado final, vá para http://mashname.appspot.com/.

Resolvendo erro de conexao no MySQL

noreply@blogger.com (Marcio Andrey Oliveira) — Wed, 15 Apr 2009 01:54:00 +0000

Um caso muito comum para quem vai usar o mysql é: criar o banco de dados, criar o usuário que terá acesso aos objetos desta base e por fim dar as permissões de acesso ao mesmo.

Aí, ao tentarmos conectar na base não conseguimos e o mysql exibe o erro

ERROR 1045 (28000): Access denied for user 'dbuser'@'localhost' (using password: YES)

ERROR 1045 (28000): Access denied for user 'dbuser'@'localhost' (using password: NO)

dependendo de termos fornecido ou não uma senha para o usuário.

Com o resolver isso?

Supondo que a base seja a dbtest e que o usuário do banco se chame dbuser. Provavelmente tu o criaste assim:


SET PASSWORD FOR dbuser = PASSWORD("dbpassword");

E aí tu deste os direitos de acesso à base desse jeito:

GRANT ALL PRIVILEGES ON dbtest.* TO dbuser IDENTIFIED BY 'dbpassword';

O problema é que para que o usuário se conecte a partir do um host qualquer, tu deves explicitamente fornecer permissões à ele.

Ou seja, as permissões de acesso devem ser dadas por host. Todos os acessos a partir de endereços que não tenham sido explicitamente permitidos serão negados.

Assim, para permitir que o usuário dbuser se conecte ao banco a partir do computador local (localhost), o comando a ser dado é:

GRANT ALL PRIVILEGES ON dbtest.* to dbuser@localhost identified by "dbpassword";

GRANT ALL PRIVILEGES ON dbtest.* to dbuser@localhost;

dependendo do fato do usuário ter senha ou não.

Tu podes obter mais informações sobre como usar o mysql com qualquer um destes livros aqui.

Agora, se for para comprar apenas um livro, o que vai responder a TODAS as tuas dúvidas, recomendo o MySQL: a Bíblia, do Steve Suehring.

Espero que este artigo te ajude.

Usando Mutt com GMail

noreply@blogger.com (Marcio Andrey Oliveira) — Tue, 14 Apr 2009 14:06:00 +0000

O Gmail é o melhor serviço de e-mail e o Firefox é o melhor browser. Mas, se tu mantiveres a página do Gmail aberta por um longo período, o Firefox consumirá muita memória do teu computador.

Se tu tens uma máquina antiga como a minha, tu sabes que cada byte é importante. Assim, eu decidi voltar a usar meu antigo cliente de e-mail: mutt (http://www.mutt.org/).

Aqui eu mostro os passos que tu precisas fazer para que o mutt possa acessar o Gmail usando o protocolo IMAP.

Eu estou usando o Ubuntu 7.04 com o mutt 1.5.13, mas o que for dito aqui deve funcionar com qualquer distribuição.

Tu deves substituir meu_email@gmail.com e minha_senha com o teu e-mail e senha do GMail.

Primeiro tu tens que habilitar o acesso via IMAP para a tua conta do Gmail. Para habilitar o IMAP faça assim:
1.1. Logue na tua conta do Gmail.
1.2. Clique em Configurações no topo da página do Gmail.
1.3. Clique Encaminhamento POP/IMAP.
1.4. Selecione Ativar IMAP.
Instale o mutt, o msmtp and o ssl. Não vou mostrar como fazer isso porque este passo é diferente para cada distribuição.

Crie o arquivo de configuração do msmtp (~/.msmtprc) como mostrado abaixo:


account default
host smtp.gmail.com
port 587
from meu_email@gmail.com
tls on
tls_starttls on
auth on
user meu_email@gmail.com
password minha_senha
logfile ~/.msmtp.log

Create mutt configuration file (~/.muttrc) as shown:


set imap_user = "meu_email@gmail.com"
set imap_pass = "minha_senha"

set from = "meu_email@gmail.com"
set realname = "Teu Nome verdadeiro"

set folder = "imaps://imap.gmail.com:993"
set spoolfile = imaps://imap.gmail.com:993/INBOX
set record=""
set postponed="imaps://imap.gmail.com/[Gmail]/Drafts"

set header_cache="~/.mutt/cache/headers"
set message_cachedir="~/.mutt/cache/bodies"
set certificate_file=~/.mutt/certificates
set move = no
set imap_check_subscribed="yes"
set imap_list_subscribed="yes"
set mbox="imaps://imap.gmail.com/[Gmail]/All Mail"
# esta linha instrui o mutt a fazer o refresh da minha caixa de entrada a cada 60 segundos
set mail_check=60
#Estou usando o character ^  para dizer para o mutt atualizar imediatamente a lista de e-mails.
bind index "^" imap-fetch-mail

Isso é tudo.

Organize os seus modelos no Simulink

noreply@blogger.com (Marcio Andrey Oliveira) — Mon, 06 Apr 2009 13:19:00 +0000

No post Como gerar Diagramas de Bode sem fazer contas no MATLAB eu mostrei uma das inúmeras facilidades que esta ferramenta nos fornece. Neste, vou mostrar como podes tornar teu modelo mais organizado com o uso de blocos.

Não fui claro? Então deixe-me explicar melhor.

Durante o desenvolvimento dos nossos modelos no Simulink, junto com o progresso da modelagem ocorre o progresso na bagunça.

Por exemplo, a figura 1 ilustra um modelo de tanque com medidor de volume desperdiçado (líquido que vazou).

Figura 1 - Diagrama com múltiplos blocos

Este diagrama, apesar de pequeno, mostra vários blocos (8, para ser mais exato). Como poderíamos tornar este modelo mais legível?

Simples. Vamos agrupar os blocos que correspondem a uma única função em uma única caixa.

No exemplo acima, os blocos Integrador, somador, Volume Total do Tanque e o bloco limitador formam, na realidade, um totalizador de vazão. Então, nada mais natural que representá-los como um único equipamento.

Para fazer isso, deves proceder assim:

1 - selecione os blocos que queres transformar um uma única caixa
2 - clique com o botão direito do mouse sobre qualquer um dos componentes selecionados. Abrirá um popup com várias ações.
3 - Selecione a opção Create Subsystem (ver figura 2).

Figura 2 - Selecionando objetos para gerar o bloco equivalente.

No lugar de todos aqueles blocos selecionados aparecerá um único, conforme mostrado na figura 3.

Figura 3 - Bloco equivalente após a criação do subsistema.

Na figura 3 podemos ver que a entrada e a saída do bloco chamam-se, respectivamente, In1 e Out1 (se houvesse mais de uma entrada e/ou saída, teríamos In2, In3,... e Out2, Out3, ...).

Ok. Para tornar mais intuitivo o que este bloco equivalente representa, vamos fazer mais algumas modificações no modelo:

1 - renomearemos o bloco de Subsystem para algo que represente melhor o que ele faz. Para isso, clique sobre o texto Subsystem e o substitua por Totalizador de Vazão.

2 - In1 e Out1 não dizem muita coisa. Vamos renomeá-los para algo que tenha algum significado para nós. Dê um duplo clique sobre o bloco que acabamos de criar. Abrirá uma janela mostrando seu interior, ou seja, os blocos que o constituem. A figura 4 ilustra o que acabei de dizer.

Figura 4 - Vista explodida do bloco Totalizador de Vazão.

Agora é só clicar sobre os textos In1 e Out1 e substituí-los por outro texto do teu interesse. Eu vou renomear In1 para Qe (vazão de entrada) e Out1 para Volume_Vazamento. A figura 5 mostra o resultado final.

Figura 5 - Modelo simplificado

Para um projeto pequeno como o demostrado neste artigo, o trabalho parece não valer a pena. mas acredite, conforme tu fores melhorando teu modelo, mais e mais blocos surgirão. Aí sim verás a necessidade e a utilidade desta técnica.

O melhor de tudo é que podes continuar com este processo indefinidamente, fazendo com que os blocos gerados sejam agrupados em outros blocos, reduzindo ainda mais o circuito.

Do mesmo modo que no post Como gerar Diagramas de Bode sem fazer contas no MATLAB, recomendo que leias pelo menos um dos livros abaixo:

Tamanho das janelas no MIDP1 e MIDP2

noreply@blogger.com (Marcio Andrey Oliveira) — Thu, 26 Mar 2009 16:48:00 +0000

Na empresa que trabalho nós fizemos um software que deveria rodar em celulares. Havia duas restrições:

- uma delas é que o código deveria rodar em celulares com MIDP1 e MIDP2. A outra é que o código deveria ser único para ambas as especificações.

No desenvolvimento do programa nós usamos Canvas para criar as nossas próprias telas, pois isso nos dá mais flexibilidade quanto ao layout do aplicativo.

Para que os componentes sempre sejam desenhados proporcionalmente ao tamanho da tela do celular (que varia muito de modelo para modelo), nós usamos duas funções da API para obtermos a largura e a altura da tela: getWidth() e GetHeight().

Ok. Testamos em vários aparelhos e nos aparelhos MIDP1 o aplicativo gerava a exceção

No such method getWidth() (e pode gerar, dependendo de quem é chamado primeiro, o erro No such method getHeight()) e morria: Os métodos getWidth() e getHeight() não existiam.

Como não? Estes métodos estão nas duas especificações. Fui examinar as APIs e descobri que, apesar de existirem, elas ficavam em hierarquias diferentes, dependendo da especificação.

java.lang.Object
extended by javax.microedition.lcdui.Displayable
extended by javax.microedition.lcdui.Canvas

Figura 1 - Hierarquia das classes Displayable e Canvas

No MIDP1, os métodos estão na classe Canvas e no MIDP2 estão em em Displayable.

Quando compilas usando as bibliotecas do MIDP2, o compilador automaticamente chama os métodos getWidth() e getHeight() de Displayable. Daí, ao rodarmos o aplicativo no celular com MIDP1, a JVM procura pelos métodos em Canvas, não os encontra e o aplicativo morre.

Agora a dúvida: como resolver isso?

Nossa classe base de desenho de telas (herda de Canvas) chama-se FormBase. Nela nós criamos os métodos


public int getWidth()  {
return super.getWidth();
}

public int getHeight()  {
return super.getWidth();
}

Isso obriga o compilador a chamar o método Canvas.getWidth() e Canvas.getHeight().

E como isto resolve o problema?

Quando estiver executando o aplicativo em um celular MIDP1, Canvas possuirá os métodos acima. Quando o aplicativo estiver executando em um celular MIDP2, Canvas não os possuirá. Aí serão chamados os métodos públicos herdados de Displayable.

Voilà! Resolvido o nosso problema de compatibilidade.

A hierarquia de classes do nosso programa é o mostrada na figura 2.

Eu recomendo que tu leias pelo menos um destes dois livros:

Core J2ME: Tecnologia e MIDP - J. W. Muchow (português)
Enterprise J2ME - Yuan, Michael Juntao (inglês)

Espero que ajude.

Figura 2 - Hierarquia do programa para rodar em MIDP1 e MIDP2

Como gerar Diagramas de Bode sem fazer contas no MATLAB.

noreply@blogger.com (Marcio Andrey Oliveira) — Wed, 25 Mar 2009 22:06:00 +0000

Suponha que você precise gerar os Diagramas de Bode para uma função qualquer. Traça-los na mão é muito trabalhoso, chato e sujeito a erros. Existe um modo mais fácil de fazer isso?

Claro que existe. Tu podes usar o Matlab. O Matlab possui algumas funções que traçam os diagramas de margem e fase. Tu só tens que fornecer a função de transferência.

Por exemplo, se a tua função de transferência for

tu podes usar a função Margin(), igual mostrado na figura 1 abaixo.

Figura 1 - Executando a função Margin

O Matlab vai gerar o gráfico mostrado na figura 2.

Figura 2 - Resultado da função Margin

Legal, não é? Mas e se a função de transferência for mais complexa? Se ela for composta por duas ou mais funções? Por exemplo a mostrada na figura 3?

Figura 3 - Função mais complexa para a qual se deseja traçar o Diagrama de Bode

Simples. Tu podes achar a função equivalente, conforme mostrado na figura 4. Daí nós simplesmente chamamos a função Margin passando a função equivalente, igual fizemos no primeiro exemplo.

Figura 4 - Função equivalente para a qual se deseja traçar o Diagrama de Bode

E se a função for mais complexa ainda. Por exemplo, igual a mostrada na figura 5?

Figura 5 - Exemplo de função mais complexa

Simples. Podemos achar a função equivalente dela, igual fizemos no exemplo anterior.

O problema com essa abordagem é que, além de trabalhosa, demorada e sujeita a erros, nem sempre é viável acharmos a função equivalente "na unha".

Devemos deixar o Matlab trabalhar para nós. Como? Simples (irritante esse negócio de ficar falando simples toda hora, não é?). Usaremos a ferramenta do Matlab chamada Simulink.

Os passos são sempre os mesmos, não importa a complexidade do circuito.

Suponha que queremos traçar o Diagrama de Bode para o circuito mostrado na figura 5.

No command Window do Matlab, digite Simulink e tecle ENTER.
Desenhar o circuito / planta para o qual se deseja traçar o Diagrama de Bode (conforme fizemos na figura 5).
Clique com o botão direito do mouse sobre a entrada do sistema e selecione Linearization Points -> Input Point.

Figura 6 - Selecionando o ponto de entrada do circuito

Aparecerá uma bolinha com uma setinha entrando nela em cima da linha de entrada do sistema. A figura 7 mostra o que estou falando.

Figura 7 - Seta vermelha mostra a entrada selecionada
Clique com o botão direito do mouse sobre a saída do sistema e selecione Linearization Points -> Output Point.

Figura 8 - Selecionando o ponto de saída do circuito

Aparecerá uma bolinha com uma setinha saindo dela em cima da linha de saída do sistema. Veja a figura 9.

Figura 9 - Seta vermelha mostra a saída selecionada
Selecione Tools -> Control Design - Linear Analysis (veja a figura 10).

Figura 10 - Selecionando a análise linear.
Na janela que abrirá, selecione Bode Response Plot no combo box (figura 11).

Figura 11 - Selecionada a análise Bode Response Plot
Clique no botão Linearize Mode (figura 12).

Figura 12 - Selecionar o botão de execução da análise linear.

Pronto. O Matlab irá gerar o Diagrama de Bode para ti. A figura 13 mostra o resultado.

A partir de agora, tu nunca mais vais precisar resolver na mão as equações. Este método é útil para outros tipos de análise, como o Diagrama de Nyquist, por exemplo.

O Matlab é uma excelente ferramenta. E, como toda ferramenta, para que possamos aproveitá-la ao máximo, devemos conhecê-la bem.

Recomendo os três livros a seguir:

Não se impressione com as palavras Engenheiros / Engenharia nos títulos. Tu não precisas ser nem engenheiro nem estudante de engenharia para usá-lo.

Tudo que eles ensinam servem para todos que precisem usar o Matlab. Escolha quantos quiser, compre-os e estude-os com afinco. Valerá a pena.

Figura 13 - Diagramas de Bode de Margem e Fase

Wasting time for nothing

noreply@blogger.com (Marcio Andrey Oliveira) — Thu, 29 Jan 2009 01:31:00 +0000

Today I was developing a new project using Django when I got the following error message:

File "/home/marcio/prj/py/ProjectManager/partlist/models.py", line 29
  friends = models.ManyToManyField("self", related_name='component_friends', symmetrical=False)
                                                                                              ^
IndentationError: unindent does not match any outer indentation level
marcio@mr02:~/prj/py/ProjectManager$

That error was caused by me because I unintentionally mixed tabs and spaces. I know I can't mix them but I did it and I wasted some precious time trying to figure out what was happening.

So if you see this error you will already know the solution. ;)

Free magazine about PIC and electronics

noreply@blogger.com (Marcio Andrey Oliveira) — Tue, 20 Jan 2009 18:31:00 +0000

Do you like electronics? And what about PIC microcontrollers?

Today I am writing to share the URL of an amazing site named MicroPIC. This site has many projects and tutorials. There is even a e-magazine named uControl they release for free.

If you can read Spanish go to http://www.micropic.es and enjoy this site. I am pretty sure you will find many interesting things there.

Correction: I made a mistake when I wrote this post. uControl is not edited by MicroPIC but by a site named uControl (it is written in Spanish too).

You will see references to the e-magazine on MicroPIC but they never claimed to be the authors.

That said I restate that MicroPIC is an amazing site. Moreover, uControl is amazing too.

Vim as the default source code viewer

noreply@blogger.com (Marcio Andrey Oliveira) — Tue, 06 Jan 2009 14:52:00 +0000

I don't like the default source viewer presented by Firefox, so I decide to use a good text editor (in fact, I'm using the best one ;).

First, type about:config in the address bar and hit ENTER.

Next, type editor in the filter bar. It will show you only entries with the word editor.

A double-click on view_source.editor.path will open a pop-up window where you must type the full address to your preferred editor: /usr/bin/gvim.

Then a double-click on view_source.editor.external will change its value to true.

From now on, GVim will be used by Firefox to show you the page source.

Merry Christmas with Bash

noreply@blogger.com (Marcio Andrey Oliveira) — Tue, 23 Dec 2008 13:57:00 +0000

Hi.

Júlio Neves wrote a shell script that draws a Christmas Tree decorated with Christmas lights.

He wishes "muito suSHELLso em 2009" that means in a free translation "much sucSHELLcess in 2009".

It is very funny. I hope you like it.

You can see the source code here: http://www.dicas-l.com.br/cantinhodoshell/cantinhodoshell_20081222.php.

Merry Christmas to Everyone.

Note: The site is written in Brazilian Portuguese, but you can just pick the code.

I am not afraid anymore

noreply@blogger.com (Marcio Andrey Oliveira) — Thu, 04 Dec 2008 23:21:00 +0000

Have you ever been afraid of changing some code? Even one that you've developed?

I have. Many times. Why this happened to me? Well, that is because I could not be 100% confident that my changes would not break any other part of the program.

My life changed when I learned the Test Driven Development methodology (aka TDD).

The idea behind TDD is that you must write automated tests before writing your code. This methodology will not only help you design better software by catching bugs at the same time you are coding, but (IMHO) it is also a great way to assure your code will keep working after maintenances.

Managers love to say they want you to deliver fully tested software. They even say that TDD is a wonderful idea. But things change when you need to fix a bug or insert new features into a product that do not have automated tests. At this moment, managers complain that there is no time to let you write a test suite to cover the entire software.

To be totally honest we need to agree that being able to fix problems and / or insert new features into your company's products in a timely manner is essential in the global market competition.

- I can not write an entire test suite to the program, and take the risk to not deliver it in a time it must be delivered. And if I do not write tests how can I assure that everything will keep working after I put my hands in it?

In this case I write tests to the part of the software that I will alter. Moreover, whenever I have a bug to fix I write tests to fully cover that part I'm working on.

Yes, I know that to be considered effective, tests must cover 100% of the program, but you must have a fresh view about it:

This approach significantly reduces the number of tests I should write to be able to check if my changes did not affect anything else. So, it will take less time and effort than the ideal situation (which my manager probably would not allow let me to do).

I will be able to write them little by little, during my development activities. The product did not have any test at all so if I write a little number of tests each time that I am working on it is better than nothing.

What you think? Is my approach good? I would like to listen to your opinion.

Blind Programmer

noreply@blogger.com (Marcio Andrey Oliveira) — Mon, 20 Oct 2008 15:09:00 +0000

I used to complain almost every day about my tendonitis.

Today I was reading a post named Programador Cego (Blind Programmer) at Aurélio's blog (It is written in Brazilian Portuguese).

This post talks aboit Ângelo Beck. He is 27 years old and he is completely blind.

Ângelo uses a screen reader and a method he developed to help him see the source code. So he is able to develop in PHP.

Ângelo proved that a blind person can do almost anything and changed my mind. He is a hero!

From now on I will never complain about my tendonitis again.

How to load debug symbols with GDB - Another Approach

noreply@blogger.com (Marcio Andrey Oliveira) — Mon, 17 Mar 2008 14:49:00 +0000

I wrote in the post How to load debug symbols with GDB one way do debug a stripped version of an application with full access to debug symbols.

In this post I will explain another way you can do it.

We are going to load debuging information from a file that was generated by our executable just before it was stripped off..

I am going to use the same source and environment settings that I used in my earlier post:

released.c: source code of the program we wish to debug (listing 1).
~/estudo/: Source code of our program will be put here.
~/local/bin: The stripped off version of binary program will stay here.
~/local/symbols: In this place are all files that contain debuging information.

#include <stdio.h>
#include <stdlib.h>

int division(int a, int b);

int m;

int main(void)
{
 int i;
 int j;

 printf("vou setar i\n");
 i = 10;

 printf("vou setar j\n");
 j = 1;

 printf ("i = %d, j = %d\n", i, j);
 m = division(i, j);

 printf("m = %d / %d = %d\n", i, j, m);

 return 0;

int division(int a, int b)
{
 return a / b;
}

Listing 1 - sample program source code

Let's start:

1 - Create your program with debug information. In our sample:

gcc -g -o release release.c <ENTER>

2 - Now we will generate a file that will contain only debug informations. You generate this file by issuing this command:

objcopy --only-keep-debug <ENTER>

In our sample:

objcopy --only-keep-debug release release.sym <ENTER>

The choice of .sym as an extension for the debug info file is totally arbitrary. You can use whatever you wish to.

3 - You remove debugging information:

strip -s release <ENTER>

4 - Move file release to ~/local/bin/:

mv release ~/local/bin <ENTER>

5 - Move file released.sym to ~/local/symbols/

mv release.sym ~/local/symbols <ENTER>

6 - Go to directory ~/local/bin

cd ~/local/bin <ENTER>

7 - Run GDB:

gdb ./release <ENTER>

8 - Try list command to see that release executable file doesn't have symbols in it.

Figure 1 shows us what I said.

Figure 1 - executable file named release is loaded by GDB.

9 - Let GDB to load symbols from symbols file named release.sym. This file has all symbols that we need to debug. You achieve this by issuing the following command:

add-symbol-file ~/local/symbols/release.sym <ENTER>

From now on you can debug your program as usual.

Figure 2 shows us that debuging symbols where imported successfully and that now the list command shows us the program source code.

Figure 2 - now our GDB session has debuging symbols

As you can see in figure 3, I set a break point at line 17 and I ran the program that stopped there. Then I printed i variable. It is possible just because symbols were loaded.

Figure 3 - debugging session.

You can see that this method to load debug symbols is easier than the previous one presented in the post How to load debug symbols with GDB.

My friend Jumpi complained that it is not the unix way to debug applications that just don't have debug information by loading a separated file. We have core files to help us to debug the application in our host.

I agree with him that it is unusual to debug this way, but it may be useful.

The idea behind this method (and behind the previous one) is similar to that used by MS with .pdb files.

It will allow you to save disk space on your host because you can keep only stripped versions of your applications and libraries in it. It is especially important to embedded systems.

At the same time it let you have a colection of symbol files stored at some place (say, a DVD disc or another server). When (and if) you need to do a debug session

I hope this post will make your life easier.

Precision Resistors

noreply@blogger.com (Marcio Andrey Oliveira) — Mon, 17 Mar 2008 02:38:00 +0000

A lot of hobbyists want to make their own circuits but they face a problem: precision resistors.

There are many projects where the ratio between resistances is more important than the actual values. In these case we can measure our resistors to select the most appropriated.

Let me show an example. Suppose we have an inverter amplifier as shown in figure 1.

Figure 1 - Inverter Amplifier

Gain is determined by equation

We can see that the circuit's gain is determined by the ratio between Rf and Ri.

Suppose we want a gain of X.

If Rf = 10,000 ohms and Ri = 5,000 ohms the gain is -2.

If Rf = 20,000 ohms and Ri = 10,000 ohms the gain is -2 too.

If we use resistors with tolerance (precision) of 5% the gain could vary between -1.81and -2.21 depending on real values of resistors Rf and Ri.

If we use resistors with tolerance (precision) of 2% the gain could vary between -1.92 e -2.08 what is much better.

What if we don't have precision resistors? What can we do?

We can use our ordinary resistors (tolerance of 5%). Take a bunch of them and measure each one until you find two resistors with a resistance ratio as near as possible of the value we wish (It is 2 in our sample).

Let me illustrate with an example. Say we take a bunch of resistors of 20K and 10K ohms (nominal values) to measure.

Suppose we found some resistors of 20,900 and 10,400 ohms. So we could do Rf = 20,900 ohms and Ri = 10,400. With these values, the gain would be -2.01 that is a better result than estimated with 2% tolerance resistors.

If we found Rf = 21,000 and Ri = 10,500 than the gain would be exactly 2.

The method, presented in this post, to use ordinary resistors instead of precision resistors is suitable only in prototype development. In commercial scale it is not feasible and the use of precision resistors is mandatory.

Note: As Maurício de Oliveira wrote in his answer to the brazilian portuguese version of this article, precision resistors are manufactured in a way that they take in account changes in their resistance by changes in temperature and manufacturers to their best to minimize it.

So, there are differences between precision resistors and ordinary resistors.

In this article (that I wrote to hobbyists), I am not taken this in account because hobbyists don't design professional circuits and then it will not cause too much trouble. Then it is a valid approuch for a experimental circuit.

How to load debug symbols with GDB

noreply@blogger.com (Marcio Andrey Oliveira) — Sat, 08 Mar 2008 04:07:00 +0000

My friend Wanderley asked me if it is possible to tell GDB to load debuging symbols from some file and use it to help debuging a program that doesn't have them.

Yes. It is.

There are two solutions to this question.

I going to explain the first solution in this post. The other solution I will explain in the next post.

You can load debuging information from an debug enabled version of executable file.

In order to better explain the first solution, I will setup my sample enviroment as follows:

released.c: source code of the program we wish to debug (listing 1).
~/estudo/: Source code of our program will be put here.
~/local/bin: The stripped off version of binary program will stay here.
~/local/symbols: In this place are all files that contain debuging information.

#include <stdio.h>
#include <stdlib.h>

int division(int a, int b);

int m;

int main(void)
{
 int i;
 int j;

 printf("vou setar i\n");
 i = 10;

 printf("vou setar j\n");
 j = 1;

 printf ("i = %d, j = %d\n", i, j);
 m = division(i, j);

 printf("m = %d / %d = %d\n", i, j, m);

 return 0;
}

int division(int a, int b)
{
 return a / b;
}

Listing 1 - sample program source code

I have two versions of the program: with and without debuging information.

1 - You compile your program with debug information. In our sample:

gcc -Wall -g -release release.c <ENTER>

2 - You make a copy of your program. In our sample:

cp release release.full <ENTER>

3 - You strip off debuging information:

strip -s release <ENTER>

As you can see on Figure 1, we have two programs. released.full has debuging symbols but release doesn't have them.

Figure 1

4 - Move file release to ~/local/bin/:

mv release ~/local/bin <ENTER>

5 - Move file released.full to ~/local/symbols/

mv release.full ~/local/symbols <ENTER>

6 - Go to directory ~/local/bin

cd ~/local/bin <ENTER>

7 - Run GDB:

gdb ./release <ENTER>

8 - Try list command to see that release executable file doesn't have symbols in it.

Note: if the program was already running you could get its PID then attach GDB to it.

Figure 2 shows us two windows. The first one shows that our executable file has no debug information. In the other window we can see that release is not yet loaded.

Figure 2 - executable file named release is loaded by GDB but it is not yet running.

9 - Let GDB to load symbols from executable file named release.full. This binary version of our program has all symbols that we need to debug.

Please notice that GDB will not replace the release executable by release.full version of our program. It will just import symbols from release.full into release debugging session.

But GDB needs to know in advance where it must put the symbols it will load. How can you determine the correct memory address?

It is quite simple. You issue command maint inside GDB:

maint info sections

Then you look for .text section. The address that is in the first column is what you want. In our sample, it is 0x08048320. See figure 3.

Figure 3 - looking for .text section address

10 - The next step is to instruct GDB to load debug symbols into .text section. To achieve it you do this:

add-symbol-file ~/local/symbols/release.full <.text section address>

In our sample it means to type:

add-symbol-file ~/local/symbols/release.full 0x08048320

From now on you can debug your program as usual.

Figure 4 shows us that debuging symbols where imported successfully and that now the list command (abbreviated as l) shows us the program source code.

Figure 4 - now our GDB session has debuging symbols

As you can see in figure 5, I set a break point at line 17 and I ran the program that stopped there. Then I printed i variable.

In the other terminal I issued ps command. It was done just to show you that the only program running was release executable. There is no instance of release.full program.

Figure 5 - debugging session.

I hope this post will make your life easier. In the next time I will teach you another way to import debuging symbols.

Using Mutt with Gmail

noreply@blogger.com (Marcio Andrey Oliveira) — Fri, 29 Feb 2008 16:46:00 +0000

Gmail is the best e-mail service and Firefox is the best browser. But if you keep Gmail's page open for a long time then Firefox will waste a lot of memory of your computer.

If you have an old machine like me, you know that each byte is important. So, I decided to come back to my old mail client: Mutt (http://www.mutt.org/).

Here I'm showing some steps you need to let mutt access Gmail with IMAP protocol.

I'm using Ubuntu 7.04 with mutt 1.5.13, but it should work with other distros.

You must replace my_mail@gmail.com and my_password occurrences with real values.

First of all you must enable IMAP access to your Gmail account. To enable IMAP in your Gmail account:
1.1. Log in to your Gmail account.
1.2. Click Settings at the top of any Gmail page.
1.3. Click Forwarding and POP/IMAP.
1.4. Select Enable IMAP.
Install mutt, msmtp and ssl. I won't show you how to do it because it is different for each distro.

Create msmtp configuration file (~/.msmtprc) as shown:


account default
host smtp.gmail.com
port 587
from my_mail@gmail.com
tls on
tls_starttls on
auth on
user my_mail@gmail.com
password my_password
logfile ~/.msmtp.log

Create mutt configuration file (~/.muttrc) as shown:


set imap_user = "my_mail@gmail.com"
set imap_pass = "my_password"

set from = "my_mail@gmail.com"
set realname = "Your Real Name"

set folder = "imaps://imap.gmail.com:993"
set spoolfile = imaps://imap.gmail.com:993/INBOX
set record=""
set postponed="imaps://imap.gmail.com/[Gmail]/Drafts"

set header_cache="~/.mutt/cache/headers"
set message_cachedir="~/.mutt/cache/bodies"
set certificate_file=~/.mutt/certificates
set move = no
set imap_check_subscribed="yes"
set imap_list_subscribed="yes"
set mbox="imaps://imap.gmail.com/[Gmail]/All Mail"
# this line instructs mutt to refresh my IMAP mailbox every 60 seconds
set mail_check=60
#I'm using ^ character to instruct mutt to update e-mail list immediately
bind index "^" imap-fetch-mail

And that's all folks.