Expressões, idéias, códigos e comentários, ...

Brasil: retrocesso de 200 anos no Estado Laico

2009-12-14T12:31:00.000-02:00

O Brasil está retrocedendo mais de 200 anos ao assinar o acordo com o Vaticano, que dá privilégios descabidos à Igreja Católica, ferindo frontalmente a Constituição da República.

Veja o Manifesto dos Batistas Brasileiros contra tal acordo: http://migre.me/dRzQ

Divulgue esta violação descabida da nossa Constituição.

Mais informações no Portal Batistas

Internet Livre - a Luta continua

2009-11-18T15:22:00.001-02:00

Reproduzo (copiado e colado) um email que recebi sobre o movimento da Internet Livre. Leitura obrigatória!

-------------------------------------------- texto colado começa aqui ------------------------------------------

Luta pela Internet Livre avança

Amigos e Amigas,

Cresce nossa mobilização contra o Projeto de Lei do Senador Eduardo Azeredo, que criminaliza práticas comuns na Internet no Brasil, como a troca de arquivos P2P e o anonimato na rede.

Em 2008 o projeto foi aprovado pelo Senado Federal e encaminhado à Câmara dos Deputados para nova tramitação.

Com sua ajuda, ao assinar a petição online contra esse AI-5 Digital, e com dezenas de atos públicos por todo o Brasil, conseguimos emperrar a votação do Projeto de Lei, mas ele ainda é uma ameaça à nossa liberdade e privacidade.

Conseguimos também fazer com que o Ministério da Justiça lançasse uma consulta pública para que o Brasil tenha um Marco Regulatório Civil na Internet. (Leia mais)

Precisamos agora que todos os que defendem a Internet Livre entrem no blog www.culturadigital.br/marcocivil ou no twitter www.twitter.com/marcocivil e exijam das autoridades nossos direitos!

Propomos que sejam considerados direitos dos cidadãos os seguintes pontos:

Todos os brasileiros têm o direito ao acesso à Internet sem distinção de renda, classe, credo, raça, cor, opção sexual, sem discriminação física ou cultural
Todos internautas têm o direito à acessibilidade plena, independente das dificuldades físicas ou cognitivas que possam ter.
Todos cidadãos brasileiros têm o direito de abrir suas redes e compartilhar o seu sinal de internet, com ou sem fio.
Todos os cidadãos têm o direito à comunicação não-vigiada.
Todo internauta tem o direito à navegação livre, anônima, sem interferência e sem que seu rastro digital seja identificado e armazenado pelas corporações, pelos governos ou por outras pessoas, sem a sua autorização.
Todo interagente tem o direito de compartilhar arquivos pelas redes P2P sem que nenhuma corporação filtre ou defina o que ele deve ou não comunicar.
Todo cidadão tem o direito que seu computador não seja invadido, nem que seus dados sejam violados por crackers, corporações ou por mecanismos de DRM.
Todo brasileiro tem direito a cópia de arquivos na rede para seu uso justo e não-comercial.
Todo cidadão tem direito de acessar informações públicas em sites da Internet sem discriminação de sistema operacional, navegador ou plataforma computacional utilizada.
Toda pessoa tem o direito a escrever em blogs e participar de redes sociais com seu nome, com codinome ou anonimamente.
Todo blogueiro tem o direito de aceitar ou não comentários anônimos, não sendo responsável pelo seu teor.

Sugiro uma lista de pessoas que estão no twitter
que estão acompanhando de perto a questão:

@caribe
@cassino
@Luiz_F_Moncau
@marcelobranco
@marcocivil
@pauloteixeira13
@rodrigosavazoni
@samadeu
@trezentos

Ou pelos sites:

www.trezentos.blog.br
meganao.wordpress.com

Ou ainda pela tag #marcovil no Twitter, e nos principais agregadores e indexadores de blogs.

Assinam esse e-mail:

Coletivo Ciberativismo

Mega Não

Projeto Software Livre Brasil

------------------------------------------- texto colado termina aqui -----------------------------------

Simplesmente diga "não" à urgência

2009-09-09T09:34:00.004-03:00

Você já recebeu um daqueles convites para ser o "salvador" de algum projeto, reunião, etc?

Algo como:

-- "Nosso palestrante teve um problema de última hora e gostaríamos de convidá-lo para substitui-lo na palestra de hoje à noite"

Eram 17:30 horas e a palestra aconteceria às 20:00 horas. O tema não é muito estranho a você, até faz parte dos seus estudos.

Mas 1:30 horas para preparar uma palestra (você tem que jantar e se deslocar, não esqueça disso!), cancelar o jantar com sua esposa e filhos, ou o cinema que você tinha prometido para eles! O que fazer?

Recentemente li um livro fantástico -- "Livres da Tirania da Urgência" de Charles E. Hummel - Editoral Press, 2001 (Editora Ultimato), que trata da administração da vida pessoal (não dá para administrar o tempo!).

Dentre várias coisas legais que o autor diz, está:

"Declinar um pedido urgente ... raramente é fácil. Mas pode ser feito ... quando você se lembra desta importante verdade:
Você é a pessoa indispensável somente até o momento em que diz não."

Uma das piores inimigas da eficácia é a urgência. "Como fogo, ela pode ser uma boa serva, mas seria ruim como mestra"

Trazendo estes conceitos para a área de TI, é impressionante como vemos a urgência dirigir departamentos inteiros. É o "Suporte", que por falta de planejamento estratégico, liderança tática e operacional adequada, vive "apagando fogo." Não que isso não tenha que acontecer, mas não raro, é a rotina diária! É "Suporte" ou "Bombeiro" ?!?

Na área de desenvolvimento, onde os prazos são sempre apertados, os "bugs" de softwares, as entregas incompletas, etc., atestam a liderança implacável da urgência, forçando códigos não testados, algoritmos não verificados e estruturas de dados e objetos que estão longe de serem eficientes. Não sobrevivem a um "upgrade" sem precisarem serem reescritos "do zero".

A menos que você pare e mude sua maneira de agir, continuará indo para o mesmo lugar e alcançando as mesmas coisas -- nada!

"Insanity -- doing the same thing over and over and expecting different results" - Albert Einstein

Se você quer que o seu futuro seja diferente, é bom começar a mudá-lo agora! Se quer que o seu código ou projeto tenha um final diferente, comece a mudá-lo agora! Planeje!

Sabe aquela rodovia que vai de São Paulo a Campinas -- a Bandeirantes. Pois é, se você dirigir por ela no sentido de Campinas, não chegará ao Litoral!

"Insanidade -- fazer a mesma coisa repetidamente e esperar resultados diferentes"

Esteja preparado para dizer não à urgência quando ela se mostrar de pouca importância!

Cria Prova - Pequenas modificações e melhorias

2008-06-27T12:12:00.007-03:00

Fiz algumas melhorias e modificações no script criaprova.
O programa agora cria provas com número de questões iguais entre os arquivos; isto permite uma prova mais balanceada.
Algumas informações sobre as provas são apresentadas, como o nome dos arquivos, o número de questões em cada arquivo, total de questões.
O programa calcula o número de questões que serão selecionadas de cada arquivo; em caso de divisão não exata, a sobra é distribuída aleatoriamente entre os arquivos - uma questão por arquivo.
Também é informada distribuição de questões por arquivo [num.questões, num.arquivo] e o número real de questões que cada prova tem; pode ser que uma prova fique com número de questões menor do que o solicitado se algum arquivo não contém questões suficientes (maior do que o número de questões por arquivo). Para executar o script usei a seguinte linha de comando:


python criaprova_v3.py 5 22 ../q1-3-20080623.txt ../q4-20080623.txt \
../q5.txt ../q6-20080623.txt

Na linha acima, o número 5 após o nome do script indica o número de provas a serem geradas; o número 22 indica o número de questões por prova e os demais são os nomes dos arquivos com as questões.

Abaixo um exemplo das informações que são mostradas:


arquivos ['../q1-3-20080623.txt', '../q4-20080623.txt', '../q5.txt', \
'../q6-20080623.txt']
arquivo 0: ../q1-3-20080623.txt  questoes:  33
arquivo 1: ../q4-20080623.txt    questoes:  15
arquivo 2: ../q5.txt             questoes:  10
arquivo 3: ../q6-20080623.txt    questoes:  14
num arquivos: 4                     total:  72

Questoes por arquivo  5
Sobra:  2   >>> Arquivo(s) que ficara(o) com a sobra:  [3, 1]
Prova:  0  dist. de questoes  [[5, 0], [6, 1], [5, 2], [6, 3]]  total  22
Prova:  1  dist. de questoes  [[5, 0], [6, 1], [5, 2], [6, 3]]  total  22
Prova:  2  dist. de questoes  [[5, 0], [6, 1], [5, 2], [6, 3]]  total  22
Prova:  3  dist. de questoes  [[5, 0], [6, 1], [5, 2], [6, 3]]  total  22
Prova:  4  dist. de questoes  [[5, 0], [6, 1], [5, 2], [6, 3]]  total  22

Este é um exemplo de prova gerada pelo script

Explorando Sistemas Operacionais com Python - Processos

2008-06-19T20:09:00.014-03:00

Um processo é a entidade básica ativa na maioria dos sistemas operacionais modernos.

Quando um usuário e criado no Unix/Linux, ele recebe um ID de usuário e um ID de grupo. O sistema utiliza os IDs de usuário e de grupo para buscar as permissões atribuídas a este usuário. O usuário mais privilegiado é o administrador de sistema, que tem o ID 0.

Um processo tem vários IDs de usuário e grupo que resultam em privilégios ao processo. Estes incluem o ID real de usuário, o ID real de grupo, o ID efetivo de usuário e o ID efetivo de grupo. Usualmente, os IDs real e efetivo são os mesmos, mas sob certas circunstâncias o processo pode mudá-los. O processo utiliza os IDs efetivos para determinar permissões de acesso a arquivos. Por exemplo, um programa que roda com privilégios de root pode querer criar um arquivo em nome de um usuário comum. Definindo o ID efetivo de usuário do processo como o do usuário, o processo pode criar arquivos "como se" o usuário os tivesse criado. Na maior parte, assumimos que os IDs real e efetivo de usuário e grupo são os mesmos.

As seguintes funções retornam os IDs de usuário e grupo para um processo. Os gid_t e uid_t são tipos inteiros representando os IDs de grupo e usuário, respectivamente. As funções getgid e getuid retornam os IDs reais, e as funções getegid e geteuid retornam os IDs efetivos.


import os
uid_t = os.getuid()
euid_t = os.geteuid()
gid_t = os.getgid()
egid_t = os.getegid()

Um processo pode criar outro processo chamando fork. O processo chamador se torna o pai e o processo criado é chamado filho.

A função fork copia a imagem da memória do pai de modo que o novo processo recebe uma cópia do espaço de endereçamento do pai. Ambos os processos continuam sua execução na instrução seguinte à declaração fork (executando em suas imagens de memória respectivas).


import os
pid_t = os.fork()

A criação de dois processos completamente idênticos não seria muito útil. O valor de retorno da função fork é a característica crítica que permite que pai e filho distinguam-se para executar código diferente. A função fork retorna 0 para o filho e retorna o ID do processo filho para o pai. Quando fork falha, ela retorna -1 e define errno. Se o sistema não tem os recursos necessários para criar o filho ou se os limites sobre o número de processos forem excedidos, fork define errno como EAGAIN. No caso de uma falha, fork não cria o filho.

No exemplo a seguir, após o fork, pai e filho imprimem seus respectivos ID's de processo.

import os,sys

childpid = os.fork()

if childpid == -1:
    print 'erro no fork'
  sys.exit()
if childpid == 0:
    print 'Eu sou o processo filho %ld' % (os.getpid())
else:
    print 'Eu sou o processo pai   %ld' % (os.getpid())

O programa a seguir cria uma cadeia de n processos chamando fork em um loop. Em cada iteração do loop, o processo pai tem um childpid não zero e interrompe o loop. O processo filho tem um valor zero de childpid e se torna um pai na próxima iteração do loop. No caso de um erro, fork retorna -1 e o processo chamador sai do loop.

import os,sys

if len(sys.argv) != 2:
    print >>sys.stderr,"Uso: %s processos\n" % (sys.argv[0])
  sys.exit(1)

n = int(sys.argv[1])
i = 1
while i<n:
  childpid = os.fork()
    if childpid > 0:
      break
   i+=1

print >>sys.stderr,"i:%d  ID do processo: %ld, ID do pai: %ld, \
ID do filho %ld\n" % (i, os.getpid(), os.getppid(), childpid)
sys.exit(0)

Por padrão, o sistema buferiza a saída escrita em stdout, de modo que uma mensagem particular pode não aparecer imediatamente após o retorno de print. Mensagens para stderr não são buferizadas, mas, ao contrário, são imediatamente escritas. Por esta razão, você deve sempre utilizar stderr para as mensagens de depuração.

O programa a seguir cria um ventilador de processos chamando fork em um loop. Em cada iteração, o processo recém criado sai do loop enquanto o processo original continua. Isto é o inverso do que acontece no programa acima.

import os,sys

if len(sys.argv) != 2:
    print >>sys.stderr,"Uso: %s processos\n" % (sys.argv[0])
  sys.exit(1)

n = int(sys.argv[1])
i = 1
while i<n:
  childpid = os.fork()
    if childpid <= 0:
      break
   i += 1

print >>sys.stderr,'i:%d ID do processo %ld, ID do pai %ld, \
ID do filho %ld\n' % (i, os.getpid(), os.getppid(), childpid)
sys.exit(0)

Estes scripts são baseados no livro Unix Systems Programming, de Robbins e Robbins, da Prentice Hall. Por serem scripts pequenos, os códigos são facilmente digitados. Quando houver algum script longo, o código fonte será disponibilizado também.

Continuarei com mais programas para explorar o Sistema Operacional.

Cria Prova - Um python script para gerar provas

2008-06-16T14:30:00.009-03:00

Este é um programa para a criação automática de provas diferentes, com questões aleatórias, a partir de um banco de questões.

A idéia deste pequeno programa veio de uma conversa com um colega (Prof. Anibal, que já utiliza uma versão DOS para as suas provas).

O programa gera, a partir do banco de questões, tantas provas diferentes e com a quantidade de questões indicadas pelo usuário.

As questões devem estar em um arquivo texto com o seguinte layout:
Q: pergunta
A: resposta 1
A: resposta 2 [opcional]

Uma pergunta pode ter várias respostas (aspectos). Neste caso, a pergunta, para ter sentido, deve ser do tipo: "Dentre as características de XXXX, está" O programa selecionará aleatoriamente, para cada prova, uma das respostas da pergunta; poder-se-á ter então, provas que tenham uma pergunta com o mesmo enunciado mas com resposta diferente. Isto é bom! Dificulta a "cola".

As perguntas podem ser separadas por linhas em branco no arquivo de questões. Mas isto é opcional.

Atualmente, o programa gera um arquivo .tex com a prova (prova_NN.tex) e um arquivo gabarito com as respostas das provas (prova_gb.tex). Futuramente, outros formatos de saída deverão ser adicionados, bem como uma interface gráfica para facilitar o uso.

Cada prova é identificada por um código de barras que contém o gabarito. Veja no código fonte informações importantes sobre os identificadores.

No arquivo gabarito, as respostas são identificadas pelo mesmo código de barras. Veja no código fonte mais informações sobre os identificadores no gabarito.

Após gerados, os arquivos das provas podem ser editados para a inserção de outras questões ou ajuste fino na formatação.

O código está abaixo, e pode ser baixado daqui

#!/usr/bin/env python
# -*- coding: ISO-8859-1 -*-

import random, sys, os

# define a quantidade maxima de questoes/respostas: 702 por enquanto.

letras_1 = ['A','B','C','D','E','F','G','H','I','J', 'K','L', 'M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']

letras_2 = [x+y for x in letras_1 for y in letras_1]

letras = letras_1 + letras_2

identificadores = ['.-' , ',+' , ':-' , '=+', ';.', '...',  ';;;', '+++', '~~~', '***']

def lequestoes(arquivos):
    """ funcao que le os arquivos e cria uma lista com todas as perguntas, que sao dicionarios"""
print 'crialista', arquivos
listao = []
respostas = []
d = dict()

# estados possiveis: fora de alguma questao 
#                    dentro de uma questao - Q - pergunta
#                    dentro de uma questao - A - respostas
# quando esta fora de uma questao e encontra um Q, deve entrar em modo questao, adicionar a pergunta ao
# dicionario
# quando esta em modo questao e encontra um A, deve entrar em modo respostas, adicionar a resposta ao
# dicionario
# quando esta em modo respostas e encontra um A, adiciona a resposta ao dicionario
# quando esta em modo respostas e encontra um Q, deve entrar em modo questao, adicionar o dicionario
# ao listao de perguntas, zerar o dicionario e as respostas
# quando esta em qualquer modo e encontra uma linha em branco, passa a proxima linha
# quando esta em modo questao e encontra um Q, significa erro no arquivo: retorna ERRO. 

for a in arquivos:
    arq = open(a)
    lista = []
    todaslinhas = arq.readlines()
    respostas = []
    estado = 'OUT'
    for linha in todaslinhas:
        if linha.startswith('Q:') and estado == 'OUT': # nova questao
            d = dict()
            estado = 'Q' # entra em modo questao
            linha = linha.lstrip(' ')
            d["q"] = linha[3:]
            d["t"] = linha[0]
        elif linha.startswith('Q') and estado == 'Q': # outra linha com Q -> erro
            print "Arquivo %s de questoes com erro linha %d " % (a, todaslinhas.index(linha))
            sys.exit(-1)
        if linha.startswith('A') and (estado == 'Q' or estado == 'A'):
            estado = 'A'  # entra em modo resposta
            linha = linha.lstrip(' ')
            if len(linha) > 4:
                respostas.append(linha[3:])
                d["a"] = respostas
            else:
                print "linha len < 4"
        if linha.startswith('Q') and estado == 'A': # nova questao
                listao.append(d)
                respostas = []
                d = dict()
                estado = 'Q'
                linha = linha.lstrip(' ')
                d["q"] = linha[3:]
                d["t"] = linha[0]
        if linha.startswith('\n'): # linha em branco separando questao
            if estado == 'A' and len(d):
                listao.append(d)
                respostas = []
                d = dict()
            estado = 'OUT'
            pass
        # fim do loop
    if estado == 'A' and len(d): # terminaram as linhas e o dicionario contem dados
        listao.append(d)
        estado = 'OUT'
        d = {}
        respostas = []
    arq.close()

return listao

def criasequencia(listao):
    """ cria uma sequencia (lista) de tuplas (q,a) a partir do listao geral de questoes """
sequencia = [] # todas as possibilidades de perguntas (tuplas do tipo (Q,A))
for q in listao:
    perg = q['q']
    resp = random.choice(q['a'])
    sequencia.append((perg,resp))
    if q['t'] != 'QNI':
        pass
return sequencia
 
def criaprovas(sequencia, numprovas,questaoporprova):
    """ cada prova eh gerada aleatoriamente a partir da lista de tuplas com todas as questoes.
    recebe como argumentos: uma lista de tuplas (q,a), o num de provas a serem geradas e 
    quantas questoes cada prova deve ter.
    retorna as provas geradas e os gabaritos; as provas sao listas de tuplas (q,a) e os gabaritos sao listas de tuplas (num questao, letra resposta)
    """
provas = []
gabaritos = []
for np in range(numprovas):
    prova = random.sample(sequencia,questaoporprova)
    provas.append(prova)
    perguntas = []
    respostas = []
    embaralha = range(len(prova))
    random.shuffle(embaralha)
    gabarito = []
    gaba_str = ''
    for i in range(len(prova)):
        gabarito.append((i+1,letras[embaralha[i]]))
    gabaritos.append(gabarito)
return provas, gabaritos
    

def crialatex(sequencia, numprovas,questaoporprova):
    """ cria um arquivo .tex para cada prova e tb o arquivo gabarito para as provas
    recebe como argumentos: uma lista de tuplas (q,a), o num de provas a serem geradas e 
    quantas questoes cada prova tera.
    cada prova eh gerada aleatoriamente a partir da lista de tuplas com todas as questoes.
    retorna as provas geradas.
    """
preambulo1 = """
\documentclass[10pt,brazil,a4paper]{article}
\usepackage[latin1]{inputenc}
\usepackage[portuguese]{babel}
%\usepackage{graphicx}
%\usepackage{multicol}
%\usepackage{shadow}
%\usepackage{pifont}
%\usepackage{listings}
%\usepackage{fancyvrb}

%\usepackage{boxedminipage}
%\usepackage{theorem}
\usepackage{verbatim}
\usepackage{tabularx}
%\usepackage{moreverb}
\usepackage{times}
%\usepackage{relsize}
\usepackage{pst-barcode}

\setlength{\\textwidth}{180mm}
\setlength{\\oddsidemargin}{-0.5in}
\setlength{\\evensidemargin}{0in}
\setlength{\\columnsep}{8mm}
\setlength{\\topmargin}{-28mm}
\setlength{\\textheight}{265mm}
\setlength{\\itemsep}{0in}
\\begin{document}
\\pagestyle{empty}
%\lstset{language=python}

                """
preambulo2= """

\\textbf{Curso:}\\rule{11cm}{0.1pt}\hspace{0.5cm}\\textbf{Turma:}\\rule{3cm}{0.1pt}

\\textbf{Nome:}\\rule{11cm}{0.1pt} \hspace{0.5cm}\\textbf{nota:} \\rule{3cm}{0.1pt}

{\scriptsize 

\\textbf{Instruções:}
\\begin{verbatim}
   1. Proibida a consulta de livros ou anotações     2. Permitido o uso de calculadoras eletrônicas
   3. Somente serão consideradas as respostas da Parte 1 na região "Gabarito" desta página
\end{verbatim}
}


\\begin{tabularx}{\linewidth}{X|X}
\\textbf{Parte 1 -- Questões} """

preambulo3 =  """

 & \\textbf{Respostas} \\\\ \hline \hline
%& \\\\

                """
        
finaltabela = """
\end{tabularx}

%\\vspace{0.3cm}

\\textbf{Parte 1 -- Gabarito:}
                  """
fimdocumento = """
    \end{document}
    """

gabatabela = """

\\begin{tabular}[t]{|b{10mm}|b{10mm}|b{10mm}|b{10mm}|b{10mm}|b{10mm}|b{10mm}|b{10mm}|b{10mm}|b{10mm}|} \\\\ \hline
    """

titulo = "\\textbf{\\centering \\large %s}" % tituloprova
provas = []
arqgaba = open('prova_'+'gb.tex','w')
arqgaba.write(preambulo1.decode('utf-8').encode("latin1"))
titulogaba = "%s \\textbf{\\large GABARITO}" % titulo
arqgaba.write(titulogaba.decode('utf-8').encode('latin1'))

for np in range(numprovas):
    prova = random.sample(sequencia,questaoporprova)
    arqprova = open('prova_'+str(np)+'.tex','w')
    arqprova.write(preambulo1.decode('utf-8').encode("latin1"))
    arqprova.write(titulo.decode('utf-8').encode("latin1"))
    arqprova.write(preambulo2.decode('utf-8').encode("latin1"))
    arqprova.write("%s" % (identificadores[np]))
    arqprova.write(preambulo3.decode('utf-8').encode("latin1"))
    #arqprova.write(initabela)


    provas.append(prova)
    perguntas = []
    respostas = []
    embaralha = range(len(prova))
    random.shuffle(embaralha)
    gabarito = []
    gaba_str = ''
    for i in range(len(prova)):
        arqprova.write("%d) %s & \n".encode('latin1') % (i+1, prova[embaralha[i]][0]))
        gabarito.append((i+1,letras[embaralha[i]]))
        gaba_str += letras[embaralha[i]]
        arqprova.write("%s) %s \\\\ \n".encode("latin1") % (letras[i],prova[i][1]))

    arqprova.write(finaltabela)
    #arqprova.write("%s" % (identificadores[np]))
    arqprova.write("\\hspace{1cm}\\begin{pspicture}(1,1in)\n")
    # a linha abaixo gera o codigo de barras do identificador (duplicado) da prova, 
    # inclui o texto no codigo de barras
    #arqprova.write("\\psbarcode[scalex=0.9,scaley=0.3]{%s%s}{includetext}{code39}\n" % (np,np))
    # gera codigo de barras usando a string do gabarito, nao inclui o texto no codigo de barras.
    arqprova.write("\\psbarcode[scalex=0.9,scaley=0.3]{%s}{}{code39}\n" % (gaba_str))
    arqprova.write("\\end{pspicture}\n")
    arqprova.write(gabatabela.encode('latin1'))
    for l in range(len(prova)):
        arqprova.write("{\\raggedright \\raisebox{0.8ex}[2.5ex][0.75ex]{%d}} ".encode("latin1") % (l+1))
        if l > 0 and (l+1) % 10 == 0:
            arqprova.write("\\\\ \hline \n")
        else:
            arqprova.write("&")
    arqprova.write("\\end{tabular}")

    arqprova.write(fimdocumento)

    arqgaba.write("\n\n\n PROVA")
    arqgaba.write("%s" % (identificadores[np]))
    arqgaba.write("\\hspace{1cm}\\begin{pspicture}(1,1in)\n")
    # a linha abaixo gera o codigo de barras do identificador (duplicado) da prova, 
    # inclui o texto no codigo de barras
    #arqprova.write("\\psbarcode[scalex=0.9,scaley=0.3]{%s%s}{includetext}{code39}\n" % (np,np))
    # gera codigo de barras usando a string do gabarito, nao inclui o texto no codigo de barras.
    arqgaba.write("\\psbarcode[scalex=0.9,scaley=0.3]{%s}{}{code39}\n" % (gaba_str))
    arqgaba.write("\\end{pspicture}\n")
    arqgaba.write(gabatabela.encode('latin1'))
    for l in range(len(prova)):
        arqgaba.write("{\\raggedright \\raisebox{0.8ex}[2.5ex][0.75ex]{%d}} %s ".encode("latin1") % (gabarito[l]))
        if l > 0 and (l+1) % 10 == 0:
            arqgaba.write("\\\\ \hline \n")
        else:
            arqgaba.write("&")
    arqgaba.write("\\end{tabular}")

    arqprova.close()

arqgaba.write(fimdocumento)
arqgaba.close()
return provas
    

tituloprova = "Avaliação Bimestral"

def main():
if len(sys.argv) > 1:
    arquivos = sys.argv[3:]
    numprovas = int(sys.argv[1])
    questaoporprova = int(sys.argv[2])
    print arquivos

else:
    numprovas = int(raw_input("entre o numero de provas: "))
    questaoporprova = int(raw_input("entre o numero de questoes por prova: "))
    entrada = raw_input("entre os nomes dos arquivos, separados por espaco: ")
    entrada.rstrip('\n')
    arquivos = entrada.split(' ')
global tituloprova
tituloprova= raw_input("Digite o titulo da prova: ")
lista = lequestoes(arquivos)
sequencia = criasequencia(lista)
provas = crialatex(sequencia, numprovas, questaoporprova)

if __name__ == '__main__':
main()

Ensinando Sistemas Operacionais com Python

2008-06-10T13:55:00.005-03:00

Python é uma excelente linguagem de programação: alto nível, de fácil aprendizagem, excelente produtividade, orientada a objeto, tipagem dinâmica, etc.

Normalmente, ela é utilizada como primeira linguagem de programação por causa destes atributos. Entretanto, ela também pode ser utilizada para coisas, digamos, mais baixo nível, como por exemplo:

Ensino de Sistemas Operacionais - exploração de chamadas de sistema para criação de processos, navegação em sistemas de arquivos, acessos a primitivas de Entrada e Saída do sistema operacional, e outras coisas a nível de SO.
Ensino de Programação de Rede - exploração de sockets, implementação de servidores variados,
Ensino de Sistemas Distribuídos, como continuação a Programação de Rede, explorando paradigmas de comunicação entre processos, sincronismo, etc.
Ensino de Inteligência Artificial - exploração de conceitos de IA, desde buscas até redes neurais, passando por processamento de linguagem natural, etc.

Enfim, Python é uma linguagem excelente para quem quer aprender bem programação e muito mais, para quem quer ensinar bem os conceitos de ciência da computação/sistemas de informação, sem se perder em merchandising e modismos mercadológicos.

2007-12-17T19:46:00.000-02:00

Educação é responsabilidade de todos.
Contradições de estudantes com relação a educação.

A educação é sabidamente uma necessidade do mundo moderno. Para ter sucesso na carreira profissional, para transitar bem nas diversas situações cotidianas, ter uma boa educação é um requisito importante.
Sabendo disto, é grande a quantidade de estudantes que ingressam no ensino superior buscando por esta melhor condição.
Entretanto, grande parte destes estudantes querem apenas o símbolo (diploma) do ensino superior ao invés do conteúdo e formação que ele representa.
Esta contradição se manifesta no dia-a-dia da sala de aula de diversas maneiras:

Alguns estudantes querem que o professor enrole na aula, que dê provas com consulta, com questões de múltiplas escolhas (alternativas) nas quais a resposta ou é óbvia ou pode ser deduzida sem esforço nenhum.
Alguns estudantes querem que o professor não exija nenhuma dedicação extra-classe, entendendo que tudo o que ele poderia precisar para passar o professor deveria ministrar em sala. Não admitem terem que estudar para aprender um tópico da aula.
Outros estudantes, com problemas gravíssimos da formação básica, exigem que o professor passe apenas conteúdo que eles possam aprender com sua precária formação. Não admitem que precisem estudar por conta própria para suprirem sua deficiência.
Outros ainda pensam que a Instituição de Ensino Superior é uma empresa que vende diplomas e que ele, cliente, por estar pagando em dia suas prestações, deve obter ao final do prazo estipulado, o referido diploma.

Estas e muitas outras são as visões que se encontram nas salas de aulas das Instituições de Ensino Superior do Brasil.
E o que elas provocam? Provocam a queda da qualidade de ensino, a queda na importância prática da educação como provedora de conhecimento e não apenas de diplomas.
Um aluno que entra na sala de aula com uma destas posturas não contribuirá em nada para o seu aprendizado e nem para o de seus colegas, já que sua postura influenciará outros.
Por melhores que sejam os professores e os recursos educacionais e didáticos que a instituição possua, serão em vão para tal aluno; o laboratório será visto apenas como lugar para acessar a Internet de graça; a biblioteca um lugar que tem umas revistas legais de informática, etc.
Uma postura correta do aluno, com interesse pelo ensino, dedicação extra-classe, leituras de textos complementares e realização dos exercícios e projetos propostos, produzirá um aprendizado efetivo, com ganho de conhecimento e novas experiências para este aluno.
O conhecimento adquirido, solidificado por suas aplicações a novas situações, propostas em aula ou experimentadas no dia-a-dia, resulta em melhores habilidades em diversas situações de vida.
A capacidade de aprendizado, exercitada durante os anos da "facu" se torna um dos mais importantes trunfos do profissional ao longo de toda a sua vida. Para se adaptar às novas tecnologias, para decidir entre uma e outra ou várias opções, ser capaz de aprender e aprender rápido faz toda a diferença. E esta capacidade se aprende na escola.
Quanto mais aprendemos, mais aprendemos a aprender, mais rápido, com mais eficiência e eficácia.
E é isso que as empresas buscam, não um diploma, que indica apenas que o portador tem ensino de terceiro grau.
Estas habilidades e conhecimento, mesmo sem diploma, podem levar alguém mais longe do que um diploma cujo dono não tem o conhecimento que ele representa.
E pior, este conhecimento será cobrado, ou por um chefe, que sabendo que sem empregado tem um diploma de curso superior, cobrar-lhe-á o respectivo conhecimento; ou por uma situação da vida, cuja solução poderia ser facilmente encontrada caso as aulas da "facu" não fossem encaradas como momentos de encontrar os amigos e discutir novidades da Internet, YouTube!, etc.
Qual é a sua escolha? Um diploma o conhecimento que ele representa?

2007-12-11T11:38:00.000-02:00

Desrespeito e pouco caso com a ciência e tecnologia.

Como minar o desenvolvimento científico e tecnológico de uma nação.

Um dia, um estudante de física, engenharia, química, ciência da computação, matemática, biologia, etc, etc, foi fazer um estágio de iniciação científica em um Instituto de Pesquisas ligado do Governo Federal. Lá, ele fez o seu mestrado e também o seu doutorado.

Por uma destas coisas que acontecem na vida, ele prestou um concurso público para o cargo de Pesquisador vinculado ao Ministério de Ciência e Tecnologia, no qual foi aprovado e para o qual foi convocado, devidamente empossado e onde, até hoje, trabalha.

Por mais inexpressiva que esta estória possa ser, ela pode ser facilmente a história de muitos Pesquisadores que, outrora "estudantes", prestaram concursos para um dos diversos Institutos de Pesquisa do MCT, como o Inmetro, a Fiocruz, o IBGE, a CNEN, etc.

Interessante, que embora sendo vinculados ao mesmo Governo Federal, exercendo a mesma função de Pesquisador, eles recebem remunerações diferentes.

Como pode um patrão contratar duas ou mais pessoas para exercerem a mesma função e pagar-lhes salários diferentes? Não pode! Quer dizer, não poderia!

Ah! Mas no Brasil, pode! E o patrão é o Governo!

Isto mesmo, um pesquisador com doutorado, ganha:

No Inmetro: de 4.652,55 a 10.361,88
Na Fiocruz: de 5.898,90 a 9.298,06
No IBGE: de 6.367,48 a 9.737,90

Mas, o mesmo pesquisador de um Instituto de Pesquisas ou outro órgão do Ministério de Ciência e Tecnologia ganha de 5.307,03 a 7.380,16. Uma diferença (a menor) de R$ 1917,90, que pode chegar a R$ 2.981,72 (a maior).

Que dizer de tal patrão?

Acontece que o Governo Federal criou recentemente carreiras separadas para o Inmetro, a Fiocruz e o IBGE para dar aumento diferenciado a estas carreiras, desrespeitando a isonomia salarial.

E este mesmo Governo ainda diz que tem um plano de aceleração para a Ciência e Tecnologia. Tratando seus pesquisadores deste modo?

Estas atitudes do Governo não são sem objetivo. Fazem parte de uma estratégia muito conhecida - "Dividir e conquistar".

Exatamente! O Governo dividiu as carreiras para que possa ganhar de cada uma delas individualmente.

Uma atitute covarde e mesquinha, tratando com desrespeito toda uma nação, que sabe que sem ciência e tecnologia, feitas com seriedade, respeito e trato igualitário, não se constrói um futuro sólido para o Brasil.

2007-12-10T21:15:00.000-02:00

Educação é responsabilidade de todos.

Contradições de patrões e chefes em relação à educação de seus funcionários e subordinados.

A qualidade da educação superior no Brasil vem caindo significativamente nos últimos tempos.
Independente do tipo de instituição que o aluno freqüenta, é bem provável que sua formação não é comparável àquela recebida por um estudante há 5 ou 10 anos.

Quando um empregador ou superior imediato de um aluno deixa de cobrar desempenho na escola, ou deixa de cobrar conhecimento compatível com a série que o aluno freqüenta, está sendo conivente com o sistema e admitindo que a qualidade da educação seja inferior. E depois, terá de pagar caros treinamentos para aquele aluno de modo a suprir-lhe a deficiência na formação acadêmica.

Não seria mais fácil, barato e melhor se o empregador ou superior imediato enxergasse a faculdade ou universidade com um momento especial na vida do seu empregado e lhe ajudasse ao máximo para que obtivesse o melhor desempenho possível, sabendo que isto reverterá para a empresa na forma de melhoria de qualidade, mais eficiência, etc.

Ao invés disto, muitos empregadores e superiores imediatos desrespeitam seus funcionários-alunos, obrigando-os a uma carga de trabalho exagerada, enviando-os para viagens demoradas a serviço, exigindo sua presença no trabalho justamente nos horários de aula.

Para estes empregadores e superiores imediatos, apresento uma carta de responsabilidade, na qual eles deverão expressar sua anuência com as práticas acima e indicar, claramente que conhecendo os prejuízos para a formação do aluno, ainda assim insistem nestas práticas e assumem a responsabilidade por prejudicar de modo permanente a formação de uma pessoa sob sua responsabilidade.

Ao
Professor Fulano de Tal
Instituição de Ensino
Localização.

Pela presente, eu _________________________, empregador/superior imediato do aluno abaixo identificado, declaro que estou ciente de:

que o horário das aulas na INSTITUIÇÃO DE ENSINO SUPERIOR é das 19:00 às 22:40 horas;
que o referido aluno precisa estar presente pontualmente às aulas, pois trata-se de curso presencial;
que o referido aluno tem direito por lei, a 1 (uma) hora para estudo em dias de prova;
que, caso a carga de trabalho do referido aluno nesta empresa exigir constantemente que o mesmo fique além do horário normal, seus estudos poderão ser prejudicados.

Declaro também, que tendo ciência dos fatos acima, assumo a responsabilidade pelo impacto na formação educacional e profissional do referido aluno, sempre que este não puder atender às aulas por motivos de trabalho exercido nesta empresa sob a minha supervisão, autorização ou solicitação, direta ou indireta.

Por fim, declaro que estou ciente de que os estudos do referido aluno quando completados com êxito, contribuirão para que esta empresa tenha um profissional melhor qualificado, com melhores resultados no seu trabalho, o que trará benefícios diretos para a empresa.

Por ser verdade, firmo o presente.

Sâo Paulo, _____ de _________________ de 200___.

Aluno: ______________________________________________

RA: _________________________________________________

Empregador - Empresa: ________________________________________

Nome: ________________________________________

Assinatura: ________________________________________

RG: __________________________________

2006-11-06T09:01:00.000-02:00

Texto e Contexto

Parece que, às vezes, o autor, Rick Warren, usa alguns textos fora do contexto, forçando algumas interpretações. O raciocínio em geral não está errado, ou seja, a idéia é bíblica, mas me parece que a escolha dos trechos, em algumas poucas ocasiões, é forçada.

Por exemplo, ao citar Jó 23.14, o objetivo era mostrar que mesmo naquela situação, Jó encontrava motivos para adorar, e um destes motivos era que Deus tinha planos para sua vida.

Isto é a pura verdade, mas o texto não me parece apontar nesta direção. Ao contrário, mostra Jó apavorado por causa dos planos de Deus "contra" ele. Jó diz: "... e tem planos semelhantes."

Mas ele estava se referindo ao decreto de Deus contra ele Jó. Não são planos 'bonzinhos'. Jó se mostra desesperado com os outros planos semelhantes de Deus.

Mas sabemos que Deus tinha planos maravilhosos para a vida de Jó, como fica claro no decorrer na sua história.

2006-10-27T13:00:00.000-03:00

A vida é uma atribuição temporária
6º dia de "Uma vida com propósitos" de Rick Warren, Ed. Vida.

A que coisas eu dou importância?

Talvez uma boa comparação contextualizada sobre o fato de a vida ser uma atribuição temporária, é pensarmos em uma viagem de férias/negócios. Por melhor que as coisas estejam, não esquecemos que voltaremos para casa. Sempre queremos ir para a nossa cama, nossa sala, etc.

Com tanta coisa "boa" nos dias atuais, é fácil esquecer que a vida não consiste em perseguiur a felicidade. Não dá para ser perfeitamente feliz e satisfeito quando se está em uma viagem, por melhor que se esteja.

Na Terra, devemos pensar assim - ansearmos o retorno ao nosso lar celestial!