Bem, eu queria muito saber como é rodar um sistema desses, emulado. Sei que a Google especifica um sistema 32bits para rodar, porém o meu sistema é de 64bits. Não desisti e corri atrás de informações.
Consegui encontrar uma mensagem no mainlist do grupo android-developers do groups(google) relacionada a isso.
Resumidamente: precisa-se instalar bibliotecas 32 bits, mas a lista é grande, então rode e instale tudo com:

#yum install glibc.i686 glibc-devel.i686 libstdc++.i686 zlib-devel.i686 ncurses-devel.i686 libX11-devel.i686 glibc.i686 ncurses-libs.i686 libgcc.i686 ncurses-libs.i686 libstdc++.i686 libX11.i686 zlib.i686 SDL.i686 libXext.i686 libXv.i686 libXrandr.i686 alsa-lib.i686 alsa-plugins-pulseaudio.i686

Em seguida rode o seu sistema emulado:

$./emulator -audio alsa @nomedasuaAVD

*-*

Não abordei a instalação do SDK porque é fácil pra caramba. Na verdade é só baixar e descompactar.
Agora vou estudar mais sobre isso… quem sabe eu consiga construir uma boa app!*-*

Para quem não conhece, o Django é como uma grande coleção de bibliotecas e rotinas prontas, feitas para agilizar o desenvolvimento de um sistema web.

Por exemplo: em um site, sempre haverá as rotinas de adicionar, editar e excluir uma determinada informação.
Programando da forma “clássica”, sem framework, você terá que criar cada processo na “mão”. Quando não há muitas coisas para criar, fica fácil, mas se é um sistema com muitas coisas para se editar, aí o bicho pega!
Com o Django, você só cria uma classe modelo, com o tipo de informação. Daí ele cria todo o processo de edição de determinada informação.
Isso não fará com que você não tenha contato com a linguagem de programação, mas simplificará todo o processo. Esse é o papel do Django!

Você pode obter mais informações no site da comunidade brasileira de desenvolvimento Django.

Se ficou interessado e deseja começar a aprender, vai no link http://www.aprendendodjango.com/ e surpreenda-se!
Mesmo se você não souber programar muito bem!
Mas terás que entender bem o padrão MVC para progredir com mais facilidade no curso.

Ainda não tive tempo para terminar o curso online, mas fiquei super animado com o que vi!

Espero encontrar muitos sites, em um futuro próximo, sendo desenvolvidos sob o Django.

Quero dizer que estou vivo e que aconteceram coisas muito legais nesse tempo todo!

Fiz 18 anos de idade! A liberdade agora está estampada na minha testa! XD
Me alistei no serviço militar, o que não foi nada legal porque tive que ir até 3 juntas por aqui(pq não sabia qual era e me informaram errado)!
Mas foi uma boa experiência!

Bom, o melhor é que estou trabalhando (supostamente) com o que gosto de fazer! Ser desenvolvedor web!

Bom, vou fazer cursinho no meu tempo vago, mas quando tiver tempo e arrumar meu PC(minha placa-mãe foi pro saco!) eu volto a postar.

Abraços!

Exemplo utilizando máscara de texto.

Hoje é um dia propício pra postagem, não me pergunte o porque.
Vou começar mostrando como se aplica máscara de entrada em um campo de texto usando uma classe pronta. Encontrei essa classe em um fórum. Provavelmente surgiu deste projeto brasileiro
(já que um dos autores é o mesmo da classe).
Siga as regras da licença.

Copie o código e salve com o nome de MaskEntry.py

#
# Copyright (C) 2006 Async Open Source
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
# USA
#
# Author(s): Johan Dahlin <[EMAIL PROTECTED]>
#

import string
import sys

import gobject
import pango
import gtk

class MaskError(Exception):
    pass

(INPUT_CHARACTER,
 INPUT_ALPHA,
 INPUT_DIGIT) = range(3)

INPUT_FORMATS = {
    'a': INPUT_ALPHA,
    'd': INPUT_DIGIT,
    'c': INPUT_CHARACTER,
    }

class MaskEntry(gtk.Entry):
    def __init__(self):
        gtk.Entry.__init__(self)
        # It only makes se
        self.modify_font(pango.FontDescription("monospace"))
        self.set_property('editable', True)
        self.set_size_request(90, -1)

        self.connect('insert-text', self._on_insert_text)
        self.connect('delete-text', self._on_delete_text)

        # List of validators
        #  str -> static characters
        #  int -> dynamic, according to constants above
        self._validators = []
        self._interactive_input = True
        self._mask = None

    # Callbacks

    def _on_insert_text(self, editable, new, length, position):
        if not self._interactive_input:
            return

        if length != 1:
            print 'TODO: paste'
            self.stop_emission('insert-text')
            return

        position = self.get_position()
        next = position + 1
        validators = self._validators
        if len(validators) <= position:
            self.stop_emission('insert-text')
            return

        validator = validators[position]
        if validator == INPUT_CHARACTER:
            # Accept anything
            pass
        elif validator == INPUT_ALPHA:
            if not new in string.lowercase:
                self.stop_emission('insert-text')
                return
        elif validator == INPUT_DIGIT:
            if not new in string.digits:
                self.stop_emission('insert-text')
                return
        elif isinstance(validator, str):
            self.set_position(next)
            self.stop_emission('insert-text')
            return

        self.delete_text(position, next)

        # If the next position is a static character and
        # the one after the next is input, skip over
        # the static character
        if len(validators) > next + 1:
            if (isinstance(validators[next], str) and
                isinstance(validators[next+1], int)):
                # Ugly: but it must be done after the parent
                #       inserts the text
                gobject.idle_add(self.set_position, next+1)

    def _on_delete_text(self, editable, start, end):
        if not self._interactive_input:
            return
        if end - start != 1:
            print 'TODO: cut/delete several'
            self.stop_emission('delete-text')
            return

        validator = self._validators[start]
        if isinstance(validator, str):
            self.set_position(start)
            self.stop_emission('delete-text')
            return

        self.insert_text(' ', end)
        return False

    # Public API

    def set_mask(self, mask):
        """
        Sets the mask of the Entry.
        The format of the mask is similar to printf, but the
        only supported format characters are:
        - 'd' digit
        - 'a' alphabet, honors the locale
        - 'c' any character
        A digit is supported after the control.
        Example mask for a ISO-8601 date
        >>> entry.set_mask('%4d-%2d-%2d')
        HACK for erase data > set_mask('%0d') 
        

        @param mask: the mask to set
        """

        self._mask = mask
        if not mask:
            return

        input_length = len(mask)
        keys = INPUT_FORMATS.keys()
        lenght = 0
        pos = 0
        while True:
            if pos >= input_length:
                break
            if mask[pos] == '%':
                s = ''
                format_char = None
                # Validate/extract format mask
                pos += 1
                while True:
                    if mask[pos] not in string.digits:
                        raise MaskError(
                            "invalid format padding character: %s" % mask[pos])
                    s += mask[pos]
                    if mask[pos+1] in INPUT_FORMATS:
                        format_char = mask[pos+1]
                        break
                    pos += 1
                pos += 1
                self._validators += [INPUT_FORMATS[format_char]] * int(s)
            else:
                self._validators.append(mask[pos])
            pos += 1

        s = ''
        for validator in self._validators:
            if isinstance(validator, int):
                s += ' '
            elif isinstance(validator, str):
                s += validator
            else:
                raise AssertionError
        self.set_text(s)

    def get_field_text(self):
        """
        Get the fields assosiated with the entry
        if a field is empty it'll return an empty string
        otherwise it'll include the content

        @returns: fields
        @rtype: list of strings
        """
        if not self._mask:
            raise MaskError("a mask must be set before calling get_field_text")

        def append_field(fields, field_type, s):
            if s.count(' ') == len(s):
                s = ''
            if field_type == INPUT_DIGIT:
                s = int(s)
            fields.append(s)

        fields = []
        pos = 0
        s = ''
        field_type = -1
        text = self.get_text()
        validators = self._validators
        while True:
            if pos >= len(validators):
                append_field(fields, field_type, s)
                break

            validator = validators[pos]
            if isinstance(validator, int):
                s += text[pos]
                field_type = validator
            else:
                append_field(fields, field_type, s)
                s = ''
                field_type = -1
            pos += 1

        return fields

    def set_text(self, text):
        """
        Sets the text of the entry

        @param text:
        """
        self._interactive_input = False
        try:
            gtk.Entry.set_text(self, text)
        finally:
            self._interactive_input = True

    def delete_text(self, start, end):
        """
        Deletes text at a certain range

        @param start:
        @param end:
        """
        self._interactive_input = False
        try:
            gtk.Entry.delete_text(self, start, end)
        finally:
            self._interactive_input = True

    def insert_text(self, text, position=0):
        """
        Insert text at a specific position

        @param text:
        @param position:
        """
        self._interactive_input = False
        try:
            gtk.Entry.insert_text(self, text, position)
        finally:
            self._interactive_input = True

def main(args):
    win = gtk.Window()
    win.set_title('gtk.Entry subclass')
    def cb(window, event):
        print 'fields', widget.get_field_text()
        gtk.main_quit()
    win.connect('delete-event', cb)

    widget = MaskEntry()
    widget.set_mask('%2d/%2d/%4d')

    win.add(widget)

    win.show_all()

    widget.select_region(0, 0)
    gtk.main()

if __name__ == '__main__':
    sys.exit(main(sys.argv))

Depois disso, você poderá testa-la rodando normalmente, assim:
$ python MaskEntry.py

Para inseri-la no seu próprio programa, faça como no exemplo:

        self.dtaemi     = MaskEntry()
        self.dtaemi.set_mask('%2d/%2d/%4d')
        self.hboxDtasBusca.pack_start(self.dtaemi,False,False,0)
        texto = gtk.Label()
        texto.set_text("e")
        self.hboxDtasBusca.pack_start(texto,True,True,0)

        self.dtavenc    = MaskEntry()
        self.dtavenc.set_mask('%2d/%2d/%4d')
        self.hboxDtasBusca.pack_start(self.dtavenc,False,False,0)

Na primeira linha é criada a entrada de texto que receberá a máscara da classe.
Em seguida é configurada a máscara para esse objeto(%2d significa 2 dígitos).
No meu exemplo eu adicionei à um hbox criado anteriormente.
Pronto, tá feito.

Obs.: Se você selecionar um “MaskEntry” utilizando a tecla tab, ele selecionará todos os campos e não conseguirá apagar e voltar para o primeiro espaço.

Bom, hoje vou mostrar um exemplo de programa escrito em Pascal, que utiliza a biblioteca gráfica GTK+ 2.
É um exemplo simples, um botão dentro de uma janela, que não possui muita utilidade prática, mas é ótimo pra se ter uma idéia do que pode ser feito com pascal.

Utilizei o Geany IDE, mas se você deseja compilar seus programas na mão, é só digitar:
$fpc arquivo.pas

Hoje vou explicar um pouco do código. Então vamos lá…

program pascal_gtk1;

uses glib2,gtk2,gdk2, crt;

Este é o início do nosso programa. A primeira linha é o nome do programa, a segunda é o mais importante aqui. Ela importa as classes necessárias para o programa funcionar.
Neste caso estamos usando a Glib 2, GTK 2, GDK 2 e a CRT.
Se você utiliza distribuições baseadas no Debian precisará instalar o compilador e as units separadamente…
Faça então:

# apt-get install fp-compiler fp-units-base fp-units-gtk2

Se você utiliza distribuições com Yum(Red Hat, Fedora, etc), faça somente:

#yum install fpc

Se você utiliza Windows, então será um pouco mais chato de instalar tudo.
Comece com o FreePascal: http://www.freepascal.org/download.html
Em seguida baixe o GTK e todos os pacotes listados(glib, pango, gdk, atk e cairo) ou este pacote tudo em um: http://ftp.gnome.org/pub/gnome/binaries/win32/gtk+/2.14/gtk+-bundle_2.14.6-20081216_win32.zip
O pacote do freepascal vem com uma IDE própria, mas é horrível!
Siga este tutorial para maior conforto(serve pra Windows também): http://icaju.wordpress.com/2008/12/22/aprendendo-a-programar-com-pascal-e-software-livre/

Seguindo o tutorial, vamos a segunda parte.

procedure destroy ( widget : pGtkWidget ; data : pgpointer); cdecl;
begin
gtk_main_quit();
end;

procedure clique( widget : pGtkWidget ; data : pgpointer); cdecl;
begin
writeln('Olá mundo');
end;

Estes são os únicos procedimentos de nosso programa. Eles recebem os parâmetros dos sinais de chamada(leia “Mantendo a sanidade com Glade”).
O primeiro procedimento é acionado quando a usuário clica no botão de fechar da janela, ou seja, destrói o programa.
O segundo procedimento é acionado quando o botão(que será criado ainda) for clicado.
Mostrarei as conexões de sinais mais à frente.

var janela:pGtkWidget;
    botao: pGtkWidget;

Aqui são declaradas as variáveis que serão utilizadas no programa. O tipo “pGtkWidget” é usado para declarar todos os Widgets GTK em FreePascal(corrija-me se estiver errado).

begin

gtk_init (@argc, @argv);

janela:= gtk_window_new(GTK_WINDOW_TOPLEVEL);
botao := gtk_button_new_with_label('Olá mundo!');

Este é o começo da “estrutura” do programa.  A função “gtk_init” iniciará tudo que seu programa precisa pra funcionar.
Para variável “janela” está sendo declarada uma nova janela gtk de nível superior.
Para variável “botao” está sendo declarado um novo botão com etiqueta.

gtk_container_add(pGTKContainer(janela),botao);

Esta linha diz para adicionar o botão à janela(um container).

gtk_signal_connect(pGTKOBJECT (janela), 'destroy', GTK_SIGNAL_FUNC(@destroy), NULL);
//Caso o botão seja clicado:
gtk_signal_connect(pGTKOBJECT (botao), 'clicked', GTK_SIGNAL_FUNC(@clique), NULL);

Estas são as linhas mais importantes do programa. São elas que conectam os sinais do programa.
A primeira conecta o widget “janela” com o sinal de “destroy” ao procedimento “destroy”.
A segunda conecta o widget “botao” com o sinal de “clicked”(clicado) ao procedimento “clique”. Ambos os procedures foram declarados anteriormente.

gtk_widget_show_all(janela);
gtk_main ();
end.

A primeira linha deste trecho fará o programa mostrar todos os widgets dentro da “janela”.
A segunda inicia o loop GTK.
A ultima linha finaliza o nosso programa.

Pra terminar, postarei o código completo.

program pascal_gtk1;

uses glib2,gtk2,gdk2, crt;

procedure destroy ( widget : pGtkWidget ; data : pgpointer); cdecl;
begin
gtk_main_quit();
end;

procedure clique( widget : pGtkWidget ; data : pgpointer); cdecl;
begin
writeln('Olá mundo');
end;

var janela:pGtkWidget;
    botao: pGtkWidget;

begin
gtk_init (@argc, @argv);

janela:= gtk_window_new(GTK_WINDOW_TOPLEVEL);
botao := gtk_button_new_with_label('Olá mundo!');

gtk_container_add(pGTKContainer(janela),botao);

gtk_signal_connect(pGTKOBJECT (janela), 'destroy', GTK_SIGNAL_FUNC(@destroy), NULL);
gtk_signal_connect(pGTKOBJECT (botao), 'clicked', GTK_SIGNAL_FUNC(@clique), NULL);

gtk_widget_show_all(janela);

gtk_main ();

end.

Programa funcionando

Observações:

Comandos iniciados com “#” significam que deverão ser executados como root.
Iniciados com “$” significam que serão executados como usuário normal.

Referências e dicas:

http://library.gnome.org/devel/gtk/stable/ (Fortemente recomendado! Em inglês)
http://linuxhard.org/wp/archives/48

http://icaju.wordpress.com/

Obrigado a todos que me ajudaram!
Próximo passo é a 2ª fase da Fuvest.
Logo logo postarei novamente!

Caso você NÃO possua o navegador proprietário Internet Explorer, e muito menos possua alguma versão do Windows, você terá a agradável surpresa de não vizualizar este site!
Claro que você pode formatar seu hd e instalar uma cópia do Windows só para acessar este site. Mas para isso, você pagará no mínimo R$400,00(a não ser que sua consciência permita comprar uma cópia pirata).

Você também pode instalar o IEs4Linux. Mas convenhamos: haja paciência!
Para testar, acesse o Censo da secretaria da educação de São Paulo e clique em algum dos links do site.

Primeiro crie uma interface como esta:

Salve com o nome que você quiser(no meu exemplo, eu salvei como Exemplo1.glade).

Em seguida crie os sinais da interface:

Feito isso, abra seu editor/IDE e insira o código comentado:

#!/usr/bin/env python
#-*- encoding: utf8 -*-

#Criação de uma liststore em Python, com PyGTK e Glade.
#Autor: Philip Sampaio

import gtk
import gtk.glade
import pygtk

pygtk.require("2.0")

class ListStoreSimples(object):
    def __init__(self):
        #Função de início.. é a primeira a ser carregada
        interface             =     gtk.glade.XML("Exemplo1.glade")
        self.winListStoreSimples    =    interface.get_widget("winListStoreSimples")
        self.entNome                =    interface.get_widget("entNome")
        self.entEmail            =    interface.get_widget("entEmail")
        self.trvListStore        =    interface.get_widget("trvListStore")

        #Montando a ListStore(ou tabela, como quiser)
        #A linha abaixo diz cria um modelo de liststore com 2 colunas, ambas sendo strings
        self.mdlListStore = gtk.ListStore( str, str)
        #A linha abaixo configura o modelo da treeview com o modelo acima
        self.trvListStore.set_model(self.mdlListStore)

        #Colocando as colunas
        colunaNome     = gtk.TreeViewColumn("Nome",gtk.CellRendererText(), text=0)
        colunaEmail    = gtk.TreeViewColumn("Email",gtk.CellRendererText(), text=1)
        #Adiciona à nossa treeview (trvListStore)
        self.trvListStore.append_column(colunaNome)
        self.trvListStore.append_column(colunaEmail)

        #Dicionário de conexões
        dic = {
            'on_winListStoreSimples_destroy' : ( self.on_winListStoreSimples_destroy ),
            'on_btnAdicionar_clicked'         : ( self.on_btnAdicionar_clicked)
            }

        #Conecta os sinais
        interface.signal_autoconnect(dic)
    def main(self):
        #Inicia o loop GTK
        self.winListStoreSimples.show_all()
        gtk.main()

    def on_btnAdicionar_clicked(self,widget):
        #Sinal de clique do btnAdicionar
        nome     = self.entNome.get_text()
        email     = self.entEmail.get_text()
        #Preste atenção: você irá adicionar os dados no MODELO
        self.mdlListStore.append([ nome, email])

        #As linhas comentadas abaixo são de exemplo.
        """info = [("Philip Sampaio","philip.sampaio@gmail.com"),
                ("Fulano"         ,"fulano@gmail.com"),
                ("Maria"         ,"Maria@gmail.com"),
                ("João"             ,"Joao@gmail.com")]
        for coluna in info:
            print coluna[0], coluna[1]
        """
    def on_winListStoreSimples_destroy(self,widget):
        #funcao para parar o loop gtk e encerrar o programa
        self.winListStoreSimples.hide_all()
        gtk.main_quit()

if __name__ == '__main__':
    teste = ListStoreSimples()
    teste.main()

O resultado deve ser algo como isto:
Fácil, não?
Teste e estude o código! Pergunte se precisar de ajuda!