Porque sou professor?

Encontrei-me imaginando se algum dia os professores seriam substituídos por máquinas, ou se perderiam seus lugares porque as pessoas seriam capazes de comprar conhecimento em um estabelecimento, como se compra arroz e feijão. Seria algo do tipo, “Me vê uma dose de capacitação em linguagem de programação C, por favor!”, e pronto estou habilitado e capacitado sem muitos esforços para desenvolver programas em linguagem de programação C. Talvez as coisas não se tornem tão simples assim, mas quem sabe, seja possível se submeter a uma cirurgia e implantar conhecimento diretamente em alguma região do cérebro responsável pela retenção do conhecimento.

Tudo bem, talvez nada disso aconteça e os professores existam por toda a eternidade em sua árdua missão de transmitir conhecimento e extrair de cada aluno o seu melhor, contudo, não é por este motivo que me tornei professor. Embora sempre apreciei meus professores e gostei de transmitir as coisas que sei, tenho que admitir que tive uma boa oportunidade e a agarrei. Digo ainda que esta não foi a única opção que tive, por isso, ser professor foi também uma escolha.

O fato de ser jovem pesa como um fator positivo e negativo. A juventude é revolucionária, é forte, é enérgica e por isso digo que ser jovem me impulsiona a ser bom, a querer maximizar o aprendizado dos meus alunos, de ser legal e diferente. Mas ao mesmo tempo, a juventude me torna inexperiente, um pouco rebelde e com pressa. O bom é que a soma final de ser jovem, deve ser mesmo assim, positiva.

Então vamos lá… Sou professor porque quero envelhecer ao lado de pessoas jovens, quero fazer novos amigos a cada seis meses, quero ajudar as pessoas a conquistarem seus objetivos, quero transmitir o que sei. Sou professor porque acredito que uma pessoa pode mudar sua vida através do conhecimento, porque é motivador ver o brilho do entendimento brilhar no olhar de uma pessoa. Sou professor porque gosto de ensinar e de aprender, gosto de estudar, gosto de me superar. Sou professor porque não gosto de rotina, porque gosto de pesquisa, porque quero me superar todos os dias.

Fiz este texto primeiramente para encontrar meus motivos e torná-los claros para mim mesmo. Tenho me dedicado para melhorar minhas aulas, tenho buscado entender melhor meus alunos, encontrar meios para mostrar para os alunos que o conteúdo pode ser entendido. Busco ser melhor porque não quero ser apenas mais um professor, quero ser um bom professor e deste modo vou tentando fazer a minha parte.

Contudo agora é a minha vez, e você porque é aluno?

Onde estão os meus óculos

Quando acordei me percebi sem eles, por um momento achei que não havia acordado ainda.

Mas pensei por um segundo. Pensei em muitas coisas. Pensei até que cabe tanto pensamento em um segundo, que por um segundo eu resolvi só pensar.

Pensei que posso fechar meus olhos e esquecer os óculos, que é até melhor não olhar nem pra trás nem pra frente, apenas andar.

Andar, andar e pensar.

O caminho pode ser longo e por isso pode ser bom fechar os olhos e parar de controlar tantas coisas. Apenas deixar me ir, com força, vontade e coragem. Os planos existem e não basta escrevê-los em papel. É necessário cumpri-los mesmo com tantas saudades e vontades.

Paro de pensar, abro os olhos e vejo que realmente perdi os meus óculos. Perder é sempre difícil, perder duas vezes é ainda mais. Mas nem por isso vou parar, vou apenas fechar os meus olhos e caminhar.

Adriano Rívolli, é professor e programador (as vezes viaja, como agora….)

mod_python – Como descobrir o ip, navegador e so do usuário ….

Para conseguir visualizar os dados enviados pelo header basta utilizar um parâmetro do objeto req da seguinte forma:

req.write(str(req.subprocess_env))

Ao se fazer isso aparecerá na tela somente alguns dados. Para se ter uma lista mais completa de dados primeiramente devemos chamar a função add_common_vars() do seguinte modo:

req.add_common_vars()

req.write(str(req.subprocess_env))

Com isso será possível notar uma lista mais rica em dados. Contudo os mais interessantes ao meu ver são:

req.subprocess_env['HTTP_USER_AGENT']  – Contém os dados do navegador, e sistema operacional utilizado pelo usuario

req.subprocess_env['REMOTE_ADDR']  – Ip do usuário

req.subprocess_env['REMOTE_ADDR'] – Query dos dados passados por GET

req.subprocess_env['SCRIPT_NAME'] – qual o caminho apartir da raiz do domínio em que esta o arquivo chamado

req.subprocess_env['SERVER_ADDR'] – Ip do servidor

req.subprocess_env['HTTP_HOST'] – Domínio do servidor

Existem mais dados que se analizados são facilmente identificados… a todos um abraço….

Como utilizar o MVC

O padrão MVC (Model View Controler) que traduzido siginifica uma camada de Modelo, Visão e Controle que também é conhecido por representar uma arquitetura de software, é bastante divulgado e comentado, entretanto ao se tentar implementar um software com esse padrão muitas dúvidas surgem e na prática ficamos com a teoria e não sabemos como efetivamente implementar esse padrão.

Após ler diversos materiais sobre o assunto gostaria de fazer um apanhado geral do que encontrei na tentativa de esclarecer o processo de desenvolvimento em 3 camadas chamado de MVC.

As funções das camadas são:

M – MODEL: Encapsula o núcleo da aplicação e a abstração dos dados

V – VIEW: Obtém os dados de um modelo e apresenta para o usuário

C – CONTROLLER: Recebe as requisições e as encaminha para processamento

Model

Esta camada deve ser independente e funcionar de forma exclusiva. Sua principal característica é fazer a abstração dos dados e dos mecanismos de armazenamento. Seu funcionamento ocorre de forma passiva, ou seja, não possui conhecimento dos níveis superior.

View

Camada de apresentação de dados. Representa a saída e fornece o mecanismo de entrada dos dados. Esta camada pode acessar diretamente o modelo para consultas (através dos métodos que esse oferece), contudo, não pode alterar o modelo.

Controller

São responsáveis pelas chamadas de métodos que alteram o modelo, sendo responsável por comunicar a camada de visão para se atualizar. Algo importante a se destacar é que esta camada não é uma ponte entre as outras duas camadas. Afinal ambos (Controller e View) tem a oportunidade de acessar o modelo.

Relacionamentos entre as camadas

• View e Controller:

Na definição do MVC as duas camadas são extremamente dependentes, de modo que o Controller é o mecanismo que o view possui para salvar os dados e os atualizar.

• View e Model:

O View depende do Model e as alterações no modelo necessitam que a visão seja alterada.

• Controller e Model:

O Controller depende do Model e as alterações no modelo são realizadas por esta camada.

Padrão de codificação em python

Definir um padrão de codificação é extremamente importante e eficaz no trabalho em equipe e legibilidade dos documentos.  Baseado no Guia de estilo para codificação em Python elaborei meu próprio estilo

IDENTAÇÃO:

4 Espaços (Não utilizar TABS e sim espaços, a maioria dos editores tem a opção de converter TABS em espaços)

LINHAS EM BRANCO:

2 Linhas em branco antes da declaração de uma função ou classe

1 Linha em branco para separar os métodos de uma classe

Linhas em branco extras podem ser usados para separa seções lógicas, grupos de funções, declarações

ENCODING:

Utilizar o UTF-8 como codificação do arquivo e na primeira linha do arquivo inserir:

# -*- coding: utf-8 -*- #

IMPORTAÇÃO DE MÓDULOS

Sempre realizar todas as importações no início do arquivo de modo que cada módulo deverá ser importado em uma linha, a não ser que se esteja especificando submódulos de um determeniado módulo. Ex:

Certo: import os                 			Errado: import sys, os

       import sys

       from subprocess import Popen, PIPE

ESPAÇOS EM BRANCO (FUNÇÕES E EXPRESSÕES)

Evitar os espaços em branco nas seguintes situações:

• Dentro de (parenteses) [colchetes] e {chaves}

  • Certo: spam(ham[1], {eggs: 2})                 Errado:  spam( ham[ 1 ], { eggs: 2 } )

• Antes de uma “,” virgula, “;” ponto e virgula e “:” dois pontos

  • Certo: if x == 4: print x, y; x, y = y, x      Errado:  if x == 4 : print x , y ; x , y = y , x

• Antes da abertura de parenteses em chamada de funções, definições e listas

  • Certo: spam(1)                                 Errado:  spam (1)

• Antes da abertura de [colchetes] de indices e {chaves} de dicionários

  • Certo: dict['key'] = list[index]               Errado:  dict ['key'] = list [index]

• Mais de um espaço em atribuições de valores

  • Certo: x = 1                                   Errado:  x       = 1

• Não utilizar espaços com em chamadas de métodos com passagem de chaves nos parâmetros e também nos dicionários

  • Certo: def complex(real, imag=0.0):            Errado: def complex(real, imag = 0.0):

Sempre utilizar espaço simples ao se trabalhar com operadores (=, +=, -=, +, -, *, <=, ==, !=, and, not, ……… )

COMENTARIOS

Devem ser identados ao mesmo nível do codigo no qual se faz pertinente e sempre será utilizado comentários de blocos iniciados por “”" e finalizados por “”" (também chamados de docstring). Ao se utilizar uma descrição breve abrir e fechar a documentação na mesma linha.

Serão comentados todas as funções que sejam públicas (exceto os get e set que são óbvios e não “possuem funcionalidades”)

CONVENÇÕES DE NOME

Nomes a evitar:

• Os seguintes caracteres: l (ele minuscúlo), O (o maiúsculo), I (i maiúsculo) como nomes de variáveis

Pacotes e módulos:

• Pacotes e Módulos devem ser curtos, com todos os caracteres em minúsculo e não utilizar underline

Classes

• UtilizarCapitalizarNomeSemExceção

Variáveis Global

• UTILIZAR_TODAS_AS_LETRAS_EM_MAIÚSCULA_E_COM_UNDERLINE

Nomes de funções e métodos

• Iniciar em minúscula para diferir das classes contudo utilizar Maiúsculas para formar mais palavras sem underline
• Métodos privados utilizam dois underlines __ no inicio do método

Variáveis, argumentos de métodos e variáveis de classes

• Sempre utilizar minusculas utilizando um underline _ separando as palavras
• Atributos privados utilizam dois underlines __ no inicio do nome

PyPgSQL exemplos práticos…

Depois de alguma teoria vamos aos exemplos que nos fazem aprender mais fácil e melhor...

Conexão com banco de dados

Criar o objeto de conexão é simples e não tem mistérios, minha dica fica com relação à codificação do banco que pode trazer problemas com os caracteres acentuados. Em minha opnião seria interessante utilizar o utf-8 e pode ser feito assim:

>>>from pyPgSQL import PgSQL

>>>con = PgSQL.connect(host="127.0.0.1",database="teste",user="postgres",password="senha",client_encoding="utf-8")

Trabalhando com dicionário ao invés de listas

O trabalho com listas é um pouco chatinho e pode gerar problemas por isso ae vai uma função que transforma a lista em dicionário

>>>def getDados(cursor):

...   indices = []

...   for i in cursor.description:

...      indices.append(i[0])

...    retorno = []

...    for row in cursor.fetchall():

...       dados = {}

...       for i in range(len(row)):

...          dados[indices[i]] = row[i]

...          retorno.append(dados)

...   return retorno

Deste modo basta chamar a função getDados passando um cursor que já executou a consulta e a mesmo retornará uma lista de dicionário onde cada dicionário corresponde a um registro e possui como indice o nome dos campos.

Tutorial básico sobre pyPgSQL

Para se utilizar um banco de dados no Python existem algumas maneiras dentre as quais vou especificar uma delas que é o pyPgSQL que permite se trabahlar com o PostgreSQL. Neste mini tutorial eu parto do principío que o mesmo já se encontra instalado na máquina.

Para se conectar ao banco de dados primeiramente é necessário importarmos o módulo para a aplicação da seguinte maneira:

>>>from pyPgSQL import PgSQL

O Próximo passo sera conectarmos no banco de dados…

>>>con = PgSQL.connect(host='servidor',database='banco de dados',user='usuario',password='senha')

Deste modo a variável con esta recebendo o objeto de conexão com o banco de dados e será apartir deste objeto que se dará a comunicação com o PostgreSQL. Note que a ordem dos parâmetros não é importante contando que seja atribuído os nomes dos mesmos corretamente. Abaixo segue a mesma conexão com um parâmetro adicional para setar o encoding.

>>>con = PgSQL.connect(host='servidor', atabase='banco de dados', client_encoding="charset", user='usuario', password='senha')

O segundo passo é a criação do cursor que executará os comandos SQL

>>>cur = con.cursor()

Neste caso o nome do cursor é cur, mais poderia ser qualquer outro nome e ainda poderia se ter diversos cursores para diversas consultas distintas. Após a criação do cursor passa-se a execução dos SQLs.

Consultas

As consultas são realizadas através do SQL “SELECT …. ” e se da pelo cursor criado do seguinte modo:

>>>cur.execute("SELECT * FROM table")

A partir deste ponto nosso cursor possui uma consulta e para acessar os dados utilizamos:

>>>linha1 = cur.fetchone()

Neste caso estamos atribuindo a variável linha1 o primeiro registro encontrado na busca. O tipo de retorno é uma lista de modo que precisamos saber exatamente a ordem das colunas, por isso é recomendado utilizar explicitamente o nome dos campos na busca SQL do seguinte modo:

>>>cur.execute("SELECT campo1, campo2, campo3 FROM table")

>>>linha1 = cur.fetchone()

>>>print linha1[0]  # Esta linha possui o valor do campo1

>>>print linha1[1]  # Esta linha possui o valor do campo2, e assim por diante até a quantidade de campos retornado pela busca

Quando acabarem os registros o fetchone retornará None

Outra maneira de obter os dados é buscando todos os registros de uma única vez

>>>dados = cur.fetchall()

Com isso a variável dados possui uma lista que tem em cada posição uma lista com uma linha do banco de dados. Com isto para saber quantos registro foram encontrados basta utilizar:

>>>len(dados)

e para acessar uma determinada linha:

>>>linha1 = dados[0]

A lista linha1 passa a ter o primeiro registro como se fosse chamado o método fetchone no exemplo anterior. Continuando verdadeiro a premissa de que é interessante estipular a ordem das colunas diretamente no SQL para evitar problemas.

Para se percorrer todos os registros basta colocar o resultado do fetchall como iterador do for:

>>>for linha in cur.fetchall():

...    print linha    # Isto irá imprimir uma lista com todos os dados do primeiro registro

Inserção, Alteração e Exclusão

Os método para realizar inserção e alteração é o mesmo exceto pelo fato de que estes deverão ser comitados ao finalizar todo o conjunto de instruções.

>>>cur.execute("INSERT INTO table (campo1,campo2) VALUES (valor1,'valor2')")

Isto faz uma inserção contudo se formos no banco de dados diretamente e olhar a inserção não estará lá porque a transação ainda não foi efetivada.

>>>con.commit()

Note que o commit é uma propriedade da conexao e não do cursor, agora sim se conferirmos no banco de dados os dados estarão lá. Este recurso parece ser meio ruim de inicio contudo ele garante benefícios para aplicação visto que em uma transação ou se executa tudo ou não se executa nada.

Uma outra característica do cursor é o rowcount que determina a quantidade de retorno, porém ele não é um método e sim uma propriedade do cursor da seguinte maneira:

>>>print cur.rowcount

Outro atributo do PgSQL é o description que descreve os detalhes dos campos encontrado em uma consulta da seguinte forma:

>>>print cur.description

O description é uma lista de campos que contem uma lista de detalhes de cada campo o nome dos campos por exemplo está no primeiro elemento desta lista. Exemplo que mostra o nome de todos os campos:

>>> for campo in cur.description:

...     print campo[0]

Através destes procedimentos temos uma idéia básica do pyPgSQL no próximo post descreverei algumas tarefas uteis para o mesmo…..

até ….

Tutorial sobre Creole

Na falta de um tutorial sobre Creole, disponível 100% na internet (O site oficial é muito instável, e na hora que se mais precisa ele está fora do ar) estou fazendo esse apanhado geral sobre a utilização da biblioteca… Quero com o tempo ir trabalhando e fazendo algo mais explicado, embora já tenha iniciado um artigo sobre o assunto.

Instalação

Em breve estarei criando um tutorial para a instalação do Creole.

Conexão

require_once 'creole/Creole.php';
$dsn = "[banco]://[usuario]:[senha]@[host]/[database]";
$conn = Creole::getConnection($dsn);

[banco] = Sigla do gerenciador do banco de dados (mysql,pgsql,…)
[usuario] = Nome do usuário para utilizar o banco de dados
[senha] = Senha para acessar o banco
[database] = nome do banco de dados

// Exemplo da utilização em um banco de dados PostgreSQL
$dsn = "pgsql://postgres:teste@localhost/banco1";

Consultas

$rs = $conn->executeQuery("SELECT * FROM user");
while($rs->next()){
     echo $rs->getString("login_name") . " (" . $rs->getInt("id") . ")";
}

Pode-se utilizar da seguinte forma:

$stmt = $conn->createStatement();
$rs = $stmt->executeQuery("SELECT * FROM user");
while($rs->next()){
     echo $rs->getString("login_name") . " (" . $rs->getInt("id") . ")";
}

Alterações

$rs = $conn->executeUpdate("INSERT INTO user (id,login_name) VALUES (1,'user2')");

Esse foi o básico do básico… para não ficar somente nisso segue a lista dos métodos do Statement e do ResultSet

Statement

public function setLimit($v);
public function getLimit();
public function setOffset($v);
public function getOffset();
public function close();
public function execute($sql, $fetchmode = null);
public function getResultSet();
public function executeQuery($sql, $fetchmode = null);
public function executeUpdate($sql);
public function getMoreResults();
public function getConnection();

ResultSet

public function getResource();
public function setFetchmode($mode);
public function getFetchmode();
public function isIgnoreAssocCase();
public function next();
public function previous();
public function relative($offset);
public function absolute($pos);
public function seek($rownum);
public function first();
public function last();
public function beforeFirst();
public function afterLast();
public function isAfterLast();
public function isBeforeFirst();
public function getCursorPos();
public function getRow();
public function getRecordCount();
public function close();
public function get($column);
public function getArray($column);
public function getBoolean($column);
public function getBlob($column);
public function getClob($column);
public function getDate($column, $format = '%x');
public function getFloat($column);
public function getInt($column);
public function getString($column);
public function getTime($column, $format = '%X');
public function getTimestamp($column, $format = 'Y-m-d H:i:s');

Web 2.0

Estou fazendo uma revisão bibliográfica sobre diversos assuntos e estarei dispobilizando aqui algumas coisas. Na verdade se trata de um trabalho acadêmico assim não poderei ficar citando muitos blogs mais no fundo este é um apanhado geral dos blogs…

Termo utilizado primeiramente pela empresa Reilly Media [1] após uma conferência em São Francisco, USA em aproximadamente outubro de 2004 [2], que descreve uma segunda versão da web, tendo novas abordagens e conceitos para se criar aplicações com características e tecnologias até então não muito empregadas [3]. O temo em si gera algumas polêmicas pelo fato da subjetividade que existe ao se classificar uma aplicação pertencendo ou não a esta nova abordagem, entretanto algumas características são claramente identificáveis conforme o próprio Tim O’Reilly descreve em seu extenso artigo sobre o assunto [3].

 

• A web como plataforma é uma das principais características que faz dos sites verdadeiros aplicativos armazenados no servidor e acessíveis em qualquer ponto com acesso a Internet, entretanto, isso exige do sistema uma maior interatividade entre o cliente e o servidor surgindo a necessidade de uma comunicação entre ambos mais eficiente. Para isso foi necessário uma ruptura no modo tradicional de requisição de páginas que consistia no carregamento de todo o conteúdo da página, deste modo, as requisições são de dados, na maioria das vezes XML, e são feitas de forma assíncrona não necessitando do carregamento de toda a estrutura da página, ou seja, passou-se a trabalhar com o Ajax. Um dos maiores e melhores exemplos são os e-mails mais precisamente o Gmail [4] e o Yahoo Mail [5] que chegam a simular alguns recursos disponíveis pelo sistema operacional como duplo cliques, teclas de atalhos e o botão invertido do mouse.

• Outra característica de destaque é o favorecimento da criação de comunidades virtuais ligadas a um determinado assunto ou fim e a facilidade com que estas podem ser criadas e divulgadas. Isto, aliado a possibilidade de, os próprios usuários gerarem o próprio conteúdo intensifica sua utilização e acelera seu crescimento de maneira que tal fato chega a se tornar um ciclo, elevando exponencialmente sua utilização e crescimento. Esta flexibilidade faz o conteúdo se tornar dinâmico através do sistema de publicação e comentários de modo que qualquer pessoa gera o conteúdo diretamente e/ou indiretamente através de comentários. Exemplos clássicos para estas características são as redes de relacionamento Orkut[6], My Space[7], You Tube[8], que permitem a interação das pessoas através de grupos virtuais, redes sociais, comunidades e fornece meios de se criar e divulgar conteúdo. Na criação de conteúdo se destaca a maior enciclopédia livre do mundo a Wikipédia [12] que conta verbetes em diversos idiomas e é escrita, revisada e corrigida por intermédio da colaboração de seus próprios usuários.

• Uma das grandes mudanças ocorreu na forma de se classificar e organizar a informação. Como a informação passa a ser o centro das aplicações o processo de taxonomia utilizado até então dá lugar para a folksonomia. Basicamente taxonomia é a classificação através de uma forma pré-fixada como acontece com os diretórios em nosso sistema operacional, ou até mesmo, como no sistema de diretórios do site de busca Cadê [9]. Com a Folksonomia a informação passa a ser rotulada através de TAGS que são criadas de acordo no a necessidade de cada um. Uma mesma informação pode ser rotulada por diversas pessoas e com TAGS diferentes que no final o senso comum entre as pessoas se obterá uma base de informações sobre a própria informação, que em alguns casos podem ser considerados até mesmo como meta dados da informação. Exemplos desta nova abordagem é o Delicious[10] que utiliza TAGS para se organizar bookmarks; o Flickr[11] que faz o mesmo para com as fotos e imagens, e com isso agrega valores tornando as imagens buscáveis e mais acessíveis.

Estes principais recursos e características descritos acima de um modo geral fornece um meio de se classificar uma aplicação pertencendo ou não à web 2.0 contudo este rótulo é meramente ilustrativo sendo importante realmente as funcionalidades criadas em benefício ao usuário final.

[1] http://www.oreilly.com/
[2] http://web2con.com/
[3] http://www.oreillynet.com/pub/a/oreilly/tim/news/2005/09/30/what-is-web-20.html
[4] http://www.gmail.com/
[5] http://mail.yahoo.com.br/
[6] http://www.orkut.com/
[7] http://www.myspace.com/
[8] http://www.youtube.com/
[9] http://br.cade.dir.yahoo.com/Internet/
[10] http://del.icio.us/
[11] http://www.flickr.com/
[12] http://www.wikipedia.com/

Colocando o blog no technorati

Acabei de cadastrar este blog no e lá me pediram para colocar esse link Technorati Profile. Para falar a verdade acredito que é só para efeito de cadastro, pois está escrito que eu poderia retirar o post, mais eu não vou fazer isso.

Para saber mais sobre o Technorati confira:

• Diga-nos Wikipédia o que é o Technorati…
• Visão Geral, de alguém, que achei no Google
• Technorati no Revolução – Blog que eu gosto muito
• Technorati no Google – para que melhor…