Umas das melhores fontes, depois do IBGE e Associação dos Municípios, seria a Wikipédia. Mas você vai clicar em 5560 páginas? Não! Existe uma maneira mais complicada e divertida de fazer isto.

Primeiro abra uma googlenilha e obtenha, com o seguinte comando, uma lista de municípios (no caso, do Rio Grande do Sul que começam com a letra A):

=importHtml("http://pt.wikipedia.org/wiki/Anexo:Lista_de_municípios_do_Rio_Grande_do_Sul";"list";1)

Você pode usar os índices de listas de cidades começando com a letra A (1) até a letra Z (26).

Em outra folha da planilha, obtenha um dado da primeira cidade da lista com este comando:

=importXML(CONCATENATE("http://pt.wikipedia.org/wiki/";Página1!A1);"//table[@class='infobox']/tr[22]/td")

O CONCATENATE monta o endereço URL da página, na Wikipédia, do primeiro município da lista, na folha Página1, célula A1.

O importXML pega a página no endereço e extrai os dados conforme o XPath (da célula <td> da 22ª linha <tr> — no caso, é a população — da tabela <table> de classe CSS “infobox”  — no caso, é a ficha do município — da primeira cidade da lista).

Puxe a célula para baixo pelo cantinho para replicá-la para todas as cidades da lista.

Na Wikipédia, espera-se que todos os dados correspondentes estejam na mesma posição da tabela, porque são gerados por “predefinições”.

Cotações

Um bom uso desta função, por exemplo, pode ser a recuperação de cotações de ações da Bovespa. Um investidor pode ter numa só planilha toda sua carteira de ações com fórmulas como esta:

=importXML("http://www.bmfbovespa.com.br/Pregao-Online/ExecutaAcaoAjax.asp?CodigoPapel=VALE3";"//Papel/@ultimo")

Troque “vale3″ por “petr3″ ou qualquer outro código de ações. Em vez de “ultimo”, podem ser filtrados os parâmetros dentro do nó <Papel Codigo=”VALE3″ Nome=”VALE ON N1″ Ibovespa=”#” Data=”19/11/2009 19:29:47″ Abertura=”48,05″ Minimo=”47,75″ Maximo=”48,80″ Medio=”48,27″ Ultimo=”48,80″ Oscilacao=”0,49″/>. Mas devem ser colocados todos em minúscula.

Para ajudar a descobrir o xPath correto dos dados, uso o plugin Firefox Xpath Generator.

Limitações

1. Por enquanto, as googlenilhas só aceitam 50 fórmulas importXML por folha.
2. Dá um trabalho do Cão. Isto é só um exemplo didático de como extrair dados da rede pelo Google Planilha. Além da Wikipédia, dá pra usar arquivos texto e CSV. Por exemplo, arquivos de cotações atualizadas frequentemente.

Bibliografia

1. XPath
2. XPath Tutorial
3. XPath Generator
4. Google. Ajuda do Docs. Funções: Que funções posso usar para obter dados externos?
5. Wikipedista hardcore Leonardo Stabile
6. Dados de cabeçalho HTTP obtidos com o plugin Live HTTP Headers para browser Firefox.

O Skype faz isso por default, mas o eMule precisa ser configurado à mão para pedir. Vá ao menu “Preferências > Conexão > Portas do Cliente” e marque “Abrir portas por UPnP”. Agora, você já sabe como obter IDs altas no eMule!

A desvantagem principal deste método é que, se cai a conexão, o eMule não sabe abrir de novo as portas por UPnP nem consegue usar as portas anteriores. Irá conectar com ID baixa. A segunda desvantagem é que ele demora mais de um minuto para conectar e para fechar.

Configuração do eMule para abrir portas automaticamente por UPnP

A configuração no modem/router Kaiomy é feita na aba “Access Management > UPnP”, ativando-se as duas opções, “UPnP” e “Autoconfigure”.

Configuração do router/modem ADSL Kaiomy para permitir abertura de portas por UPnP

No router wifi Linksys WRT54G, habilite o UPnP na aba “Administração > Gestão > UPnP”.

Configurar router wifi WRT54G para permitir abertura de portas por UPnP

Como instalar UPnP no Windows XP

O UPnP também pode ser usado pelo Windows para mostrar o ícone do router na pasta de conexões de rede. para isto funcionar, deve ser instalado um programinha pelo “Painel de controle > Adicionar ou remover programas >  Adicionar/remover componentes do Windows > Serviços de rede > Interface de Usuário Plug and Play Universal”.

Com o serviço instalado, fica mais fácil acessar a interface Web do router. E se algum programa ainda não sabe usar UPnP, você pode configurar as portas pelo próprio Windows, sem precisar acessar a interface do router, conforme mostra a ilustração abaixo. Mostrar o ícone na bandeja do sistema facilita o acesso.

Abrindo portas por UPnP no Windows XP

Aviso (caveat)

Há alguns anos, existiam vulnerabilidades no sistema UPnP do Windows. Mas certamente esse problema já deve ter sido resolvido. No entanto, o UPnP permite que qualquer programa abra as portas do router, numa rede interna. Isto não é problema numa rede doméstica ou de pequenas empresas, mas empresas maiores podem querer impedir que seus funcionários usem estes recursos de internet. Neste caso, é bom desligar o UPnP.

Pois o recém-lançado Google Chrome Beta também tem seus “abouts:”, e um hacker já os descobriu:

about:version - informação sobre a versão (também acessível com "chrome-resource://about/")
about:plugins - plugins instalados
about:histograms - gráficos ASCII com algumas informações estranhas.
about:dns - alguns status do DNS.
about:cache, sinônimo de "view-cache:" - lista dos documentos cacheados, visíveis em hexadecimal.
view-cache:stats - status de documentos guardados no cache.
about:stats - estatísticas de uso.
about:memory - mostra uso de memória.
about:network - interessante ferramenta de análise.
about:internets - possivelmente um "ovo de páscoa", um screensaver de tubos.
about:crash - tela de crash
about:hang - termina o processo atual (aba atual)
about:% - congela todo o Chrome. Só resta fechá-lo.
chrome-resource://new-tab/ - um template para páginas vazias.
chrome-resource://favicon/ - favicon em representação de caracteres.

Via Google Chrome – Saulis.com, Peopleware, Google Operating System.

Matéria montada automaticamente pelo script.

Que tal abrir um quadro de texto no Scribus, rodar um script e obter rapidamente uma matéria jornalística montada, com foto, legenda e crédito da foto? E que tal levar todo um sistema editorial num pen drive? (Editor de texto, editor de fotos, paginador, saída em PDF/X-3). E que tal tudo isto com ferramentas gratuitas e de código aberto?

Essa foi minha idéia ao aprender Python e Scribus Scripting. Levar um sistema editorial de categoria profissional num pen drive. Instalei o X-Scribus, um Scribus especial para pen drives. Ele já tem o Ghostscript, Python e tudo o que é necessário para rodar em qualquer computador com Windows. Existe mais uma versão, o Portable Scribus 1.3.3.12, mas ele me apresentou problemas na visualização de impressão: não permitia a seleção de chapas (plates) individuais — ciano, magenta, amarelo ou preto, coisa importante para o ensino de seleção de cores.

Imagens

Para automatizar o Scribus, uma das primeiras providências é permitir ao Python do Scribus a manipulação de imagens. Para isso, usei PIL (Python Image Library).

No Linux, o Scribus usa o Python normal do sistema. Instale as bibliotecas PIL da forma usual de seu sabor de Linux. No Windows, o instalador do Python Image Library precisa de certas chaves no registro do Windows para saber em que lugar está instalado o sistema Python. Eu defini estas chaves para a pasta do Scribus, que é onde roda o interpretador Python no Windows. Ao baixar o PIL, cuide as versões: no Scribus versão 1.3.3 estável,  o Python é versão 2.4. No Scribus 1.3.4 Beta, o Python é versão 2.5.

Para registrar o Python do Scribus, o meu arquivo reg tem o seguinte:

Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SOFTWARE\Python]
[HKEY_LOCAL_MACHINE\SOFTWARE\Python\Pythoncore]
[HKEY_LOCAL_MACHINE\SOFTWARE\Python\Pythoncore\2.4]
[HKEY_LOCAL_MACHINE\SOFTWARE\Python\Pythoncore\2.4\InstallPath]
@="c:\\SD\\PortableApps\\X-Scribus\\Bin\\Scribus\\"
[HKEY_LOCAL_MACHINE\SOFTWARE\Python\Pythoncore\2.4\PythonPath]
@="c:\\SD\\PortableApps\\X-Scribus\\Bin\\Scribus\\Lib\\;c:\\SD\\PortableApps\\X-Scribus\\Bin\\Scribus\\DLLs\\"

[HKEY_LOCAL_MACHINE\SOFTWARE\Python\Pythoncore\2.5]
[HKEY_LOCAL_MACHINE\SOFTWARE\Python\Pythoncore\2.5\InstallPath]
@="c:\\SD\\Bin\\Scribus\\"
[HKEY_LOCAL_MACHINE\SOFTWARE\Python\Pythoncore\2.5\PythonPath]
@="c:\\SD\\Bin\\Scribus\\Lib\\;c:\\SD\\Bin\\Scribus\\DLLs\\"

Se você precisar registrar, copie este código, mude os caminhos para as pastas para casarem com seu sistema (em vermelho) e grave como texto simples, com a terminação .reg. Dê dois clics no arquivo para registrar as chaves no registro do Windows.

Depois de instalado o PIL, se as bibliotecas de imagem forem corretamente reconhecidas, não haverá erros ao rodar o script de montagem de matérias.

Repare que instalei tudo usando o HD. Depois de tudo instalado, copiei a pasta inteira para o pen drive. No caso, copiei a pasta X-Scribus para a pasta PortableApps (que é o padrão de aplicações portáteis que uso) do pen drive.

A seguir coloquei o script na pasta de scripts do Scribus, que no meu caso coloquei em c:\SD\PortableApps\X-Scribus\Bin\Scribus\Scripts.

No início do script existem algumas variáveis que podem ser modificadas pelo usuário, como a largura da valeta (gutter, espaço entre as colunas).

O script funciona assim: desenhe um retângulo ou selecione um. Vá ao menu Scripts, procure e rode este script. Aparecem diversas janelinhas de diálogo perguntando:

• Em quantas colunas será dividida a área de colunas da matéria? Escolha 2 ou mais.
• Qual a largura do espaço entrecolunas (gutter ou valeta)?
• Qual o corpo (tamanho) do sobretítulo?
• Qual o corpo do subtítulo?
• Quantas fotos tem a matéria? Por enquanto, o script só aceita uma.
• Quantas colunas ocupa a foto (de largura)? A foto é posicionada ao lado da primeira coluna de texto e agrupada com quadros para legenda e para crédito. As bibliotecas PIL são usadas para isto. As funções PIL medem a foto escolhida e o script calcula a altura do quadro de foto. Mais tarde, uso a tecla CTRL + Y para abrir o editor de texto interno do Scribus para editar os dois elementos (como se faz no Adobe inDesign). Na primeira linha vai a legenda e na linha de baixo vai o crédito.

Falta fazer as rotinas para manipular fotos no caso de uma matéria em apenas uma coluna. Se você escolher uma coluna, a foto será montada ao lado da matéria.

A seguinte seqüência de quadros mostra como funciona o script.

O quadro para título vai agrupado com o quadro para as colunas. Para editar o texto, uso a tecla CTRL + Y. Para importar texto, seleciono o grupo e uso CTRL + D (como no PageMaker e InDesign).

#!/usr/bin/env python2.4
# -*- coding: utf-8 -*-

"""
Build a newspaper story
By prof. MS. José Antonio Meira da Rocha
mailto:joseantoniorocha@gmail.com

http://meiradarocha.jor.br

Licença GPL
"""

import sys

###########################
# Assegura que está rodando
# dentro do Scribus
###########################
try:
	import scribus
except ImportError,err:
	print "This Python script is written for the Scribus scripting interface."
	print "It can only be run from within Scribus."
	sys.exit(1)

# Carrega algumas constantes Scribus usadas neste script
from scribus import UNIT_POINTS, LINE_SOLID, JOIN_MITTER, BUTTON_OK, ICON_WARNING

#########################
# USER IMPORTS GO HERE  #
#########################

#####################################
# Usuário pode mudar estes parâmetros
#####################################
numeroDeColunasPadrao = "3"
entrecolunasPadrao = "14.1732"  # 5mm
corpoDeTituloPadrao = "48"
corpoPadraoDoSobretitulo = "18"
proporcaoDeEntrelinha = 1.0

##########################################
# Constantes que NÃO devem ser modificadas
AROUND_FRAME = 1
BOUNDING_BOX = 2
CONTOUR_LINE = 3 

######################
# Locale strings
# Textos para tradução
######################
pedirParaAbrirDoc = "<h2>Abra um documento</h2>" \
	+"Ops! Abra um documento antes \nde rodar este comando."
pedirParaAbrirQuadro = "<h2>Desenhe um quadro</h2>\n" \
	+"Ops! Desenhe ou selecione um <b>quadro</b>\n" \
	+"na área em que você quer montar a matéria."
#
labelDeColunas = 'Colunas' #Number of columns
mensagemDeColunas = '<h2>Colunas</h2><p>Quantas colunas?</p>'  #How many columns?
#
labelDeCorpoDeTitulo = "Corpo do título" #quadroDeTitulo
mensagemDeCorpoDeTitulo = "<h2>Corpo do título</h2><p>Qual&nbsp;o&nbsp;corpo&nbsp;do&nbsp;título?</p>" #What the quadroDeTitulo size?
#
labelDeValetas = "Valetas"
mensagemDeValetas = "<h2>Valetas</h2><p>Qual&nbsp;o&nbsp;tamanho&nbsp;da&nbsp;valeta?\n(Espaço&nbsp;entrecolunas)"
#
labelDeSobretitulo = "Corpo do sobretítulo"
mensagemDeSobretitulo = "<h2>Corpo do sobretítulo</h2>\n<p><b>Qual&nbsp;o&nbsp;corpo&nbsp;do&nbsp;sobretítulo?</b>\n" \
	+ "(coloque&nbsp;zero&nbsp;se&nbsp;não&nbsp;houver&nbsp;sobretítulo)"
#
textFlowsAroundFrame = 'Abra a imagem'
filtroDeImagens = 'Arquivos de imagens (*.jpg *.png *.tiff *.tif)'
#
labelDeImportarTexto = "Abra o texto"
filtroDeArquivosTexto = "Arquivos de texto (*.txt *.html)"
#
labelDeLarguraDeImagem = "Largura da imagem"
mensagemDeLarguraDeImagem = "<h2>Largura&nbsp;da&nbsp;Imagem</h2>\nQuantas&nbsp;colunas&nbsp;a&nbsp;imagem&nbsp;ocupará?"
larguraDeColunasPadrao = "1"
#
labelDeImagem = "Quantas fotos"
mensagemDeImagem = "<h2>Quantas fotos?</h2>\n<p>Quantas&nbsp;fotos&nbsp;a&nbsp;matéria&nbsp;tem?"
numeroDeImagemPadrao = "1"

labelDeQuadroDeTitulo = "Montar matéria"

labelErroDeImportacao = "Não importei o arquivo"
msgDeErroDeImportacao = "<h2>Não importei o arquivo</h2><p>Desculpe-me, não importei o arquivo por algum detalhe de formato incompatível ou arquivo não encontrado. <b>Sem problema</b>, tente de novo manualmente nais tarde.</p>"

labelAbreDoc = "Abra um documento"
dizAbreDoc = "<h2>Abra um documento</h2><p>Por favor, este comando exige que você abra um documento.</p>"

####################
# End Locale strings
####################

try:
	import Image
except ImportError,err:
	print "This Python script is written for the PIL graphic interface."
	print "It should be instaled in Scribus Python tree."
	sys.exit(1)

def pedeNumeroDeColunas():
	"""Pede número de colunas de texto que terá a matéria"""

	numeroDeColunas = scribus.valueDialog(
		labelDeColunas,
		mensagemDeColunas,
		numeroDeColunasPadrao
	)
	if not numeroDeColunas:
		sys.exit()
	try:
		return int(numeroDeColunas)
	except:
		return numeroDeColunasPadrao

def pedeCorpoDoTitulo():
	"""Pede tamanho das letras (corpo) do título, em pontos tipográficos."""
	corpoDeTitulo = scribus.valueDialog(labelDeCorpoDeTitulo, mensagemDeCorpoDeTitulo, corpoDeTituloPadrao)
	if not corpoDeTitulo:
		sys.exit()
	try:
		return float(eval(corpoDeTitulo))
	except:
		return float(corpoDeTituloPadrao)

def pedeEntrecolunas():
	"""Pede o espaço entre as colunas de texto (gitter, valeta), em pontos tipográficos"""
	entrecolunas = scribus.valueDialog(labelDeValetas, mensagemDeValetas, entrecolunasPadrao)
	if not entrecolunas:
		sys.exit()
	try:
		return float(entrecolunas)
	except:
		return entrecolunasPadrao

def pedeCorpoDoSobretitulo():
	"""Pede tamanho das letras (corpo) do sobretítulo, em pontos tipográfico"""
	corpoDoSobretitulo = scribus.valueDialog(labelDeSobretitulo, mensagemDeSobretitulo, corpoPadraoDoSobretitulo)
	if not corpoDoSobretitulo:
		sys.exit()
	try:
		return float(eval(corpoDoSobretitulo))
	except:
		return float(corpoPadraoDoSobretitulo)

def pedeImagem():
	"""Pergunta por fotos na matéria"""
	temImagem = scribus.valueDialog(labelDeImagem, mensagemDeImagem, numeroDeImagemPadrao)
	if not temImagem:
		sys.exit()
	try:
		return temImagem
	except:
		return temImagem

def pedeTexto(quadroDeTitulo):
	"""Load text file"""

	sourceCharcode = 'iso-8859-15' # change it to ur language
	# Diálogo de procurar arquivo
	textFile = scribus.fileDialog(labelDeImportarTexto,filtroDeArquivosTexto,"", haspreview=1, issave=True) # issave=False shows "Save" button
	if textFile:
		try:
			t = open(textFile).read()
			t = unicode(t, sourceCharcode)
		except:
			scribus.messageBox(
				labelErroDeImportacao,
				msgDeErroDeImportacao,
				ICON_WARNING,
				BUTTON_OK
			)
			t=""
			return t
	else:
		t=""

	return t

def flow(frame,mode):
	"""Compatibiliza Scribus 1.3.3 e 1.3.4"""
	try:
		scribus.textFlowsAroundFrame(frame, mode) # Scribus 1.3.3
	except:
		scribus.textFlowMode(frame, mode)		 # Scribus 1.3.4

def pedeColunasDeImagem():
	"""Solicita a quantidade de colunas que a foto vai ocupar."""
	colunasDaFoto = scribus.valueDialog(
	labelDeLarguraDeImagem,
	mensagemDeLarguraDeImagem,
	larguraDeColunasPadrao
	)
	if not colunasDaFoto:
		sys.exit()
	try:
		return float(eval(colunasDaFoto))
	except:
		return float(larguraDeColunasPadrao)

def pedeFoto():
	"""	Escolhe arquivo de foto
	scribus.fileDialog('caption', ['filter', 'defaultname',haspreview, issave])"""

	# Abre diálogo para escolha de arquivo
	arquivoDaFoto = scribus.fileDialog(
		textFlowsAroundFrame,
		filtroDeImagens,
		"",  # Nome default do arquivo
		haspreview=1,
		issave=True
	)

	# Tenta abrir arquivo fornecido
	try:
		foto = Image.open(arquivoDaFoto)  # uso da biblioteca PIL
	except:
		scribus.messageBox(
			labelErroDeImportacao,
			msgDeErroDeImportacao,
			ICON_WARNING,
			BUTTON_OK
		)
		foto = ""
	return foto,arquivoDaFoto

def montaQuadroDaFoto(quadroDeColunas):
	"""Build a image frame with credit and legenda
	based in text frame number of columns"""

	#
	foto,arquivoDaFoto = pedeFoto()
	try:
		larguraDaFoto,alturaDaFoto = foto.size  # para pegar o tamanho da imagem em pixels
	except:
		larguraDaFoto,alturaDaFoto = 4,3  # Se não conseguir, define proporção 4 por 3

	# Escolhe quantas colunas a foto vai "abrir"
	colunasDaFoto = pedeColunasDeImagem()

	# Calcula largura da foto
	entrecoluna = scribus.getColumnGap(quadroDeColunas)
	colunasDeTexto = scribus.getColumns(quadroDeColunas)

	# Define o tamanho da foto
	larguraDoQuadroDeColunas,alturaDoQuadroDeColunas = scribus.getSize(quadroDeColunas)

	larguraDaColuna = (larguraDoQuadroDeColunas - (entrecoluna*(colunasDeTexto-1))) / colunasDeTexto

	# calcula posição da imagem
	quadroDeColunasEsquerda, quadroDeColunasTopo = scribus.getPosition(quadroDeColunas)

	# Posiciona foto a partir da segunda coluna de texto
	quadroDaFotoEsquerda = quadroDeColunasEsquerda + larguraDaColuna + entrecoluna
	quadroDaFotoTopo = quadroDeColunasTopo

	# Calcula largura e altura da imagem
	larguraDoQuadroDaFoto = colunasDaFoto * larguraDaColuna + (entrecoluna * (colunasDaFoto - 1))
	alturaDoQuadroDaFoto = larguraDoQuadroDaFoto * alturaDaFoto / larguraDaFoto

	# Cria quadro de imagem com a foto
	quadroDaFoto = scribus.createImage(quadroDaFotoEsquerda, quadroDaFotoTopo, larguraDoQuadroDaFoto, alturaDoQuadroDaFoto)

	# Define fluxo para "Afastar texto"
	flow(quadroDaFoto, AROUND_FRAME) 

	# Define formatação gráfica do quadro de foto
	scribus.setLineWidth(	   0.8, quadroDaFoto)
	scribus.setLineColor(   "Black", quadroDaFoto)
	scribus.setLineShade(	   100, quadroDaFoto)
	scribus.setLineStyle(LINE_SOLID, quadroDaFoto)
	scribus.setLineJoin(JOIN_MITTER, quadroDaFoto)
	try:
		scribus.loadImage(arquivoDaFoto, quadroDaFoto)
	except:
		print "Não pude carregar a imagem."

	# Calcula escala da imagem para caber no quadro
	escalaDaFoto = larguraDoQuadroDaFoto / larguraDaFoto

	# Resescalona quadro de imagem
	scribus.scaleImage(escalaDaFoto, escalaDaFoto, quadroDaFoto)

	########################################
	# LEGENDA
	########################################
	# Calcula dimensões do quadro de legenda
	quadroDaLegendaTopo = quadroDaFotoTopo + alturaDoQuadroDaFoto
	alturaDoQuadroDaLegenda = entrecoluna * 2
	# Cria quadro de legenda
	quadroDaLegenda = scribus.createText(quadroDaFotoEsquerda, quadroDaLegendaTopo, larguraDoQuadroDaFoto, alturaDoQuadroDaLegenda)
	#
	# Melhoria: Colocar leitor de input para escrever legenda

	# Liga "afastador de texto"
	flow(quadroDaLegenda, AROUND_FRAME)

	##########################################
	# CREDITO
	##########################################
	# Define medidas do quadro para crédito de foto
	quadroDaFotoDireita = quadroDaFotoEsquerda + larguraDoQuadroDaFoto
	quadroDaFotoBaixo = quadroDaFotoTopo + alturaDoQuadroDaFoto
	# Cria quadro de crédito
	quadroDoCredito = scribus.createText(quadroDaFotoDireita, quadroDaFotoBaixo, alturaDoQuadroDaFoto, entrecoluna)
	#
	# Melhoria: Colocar input de crédito para escrever credito
	#   if not finalizado
	#	  processaNaoFinalizado()

	# Liga "afastador de texto"
	flow(quadroDoCredito, AROUND_FRAME)

	# Agrupa os elementos foto, legenda e crédito
	scribus.groupObjects([quadroDaFoto, quadroDaLegenda, quadroDoCredito])

	# Se tiver a legenda e crédito no mesmo arquivo que o texto da matéria
	#scribus.linkTextFrames(quadroDeTitulo, quadroDaLegenda)

	# Liga os textos da legenda e dos créditos
	scribus.linkTextFrames(quadroDaLegenda, quadroDoCredito)

	# Se tiver a legenda e crédito no mesmo arquivo que o texto da matéria
	#scribus.linkTextFrames(credit, quadroDeColunas)

	# Deixa o quadro de legenda "em pé"
	scribus.rotateObject(90, quadroDoCredito)

def montaMateria(espacoDaMateria):
	""" Manipula um bloco de notícia """

	# Pega as coordenadas X e Y do objeto selecionado
	esquerdaDoQuadro, topoDoQuadro = scribus.getPosition(espacoDaMateria)
	# Pega a largura e altura do quadro
	larguraDoQuadro, alturaDoQuadro = scribus.getSize(espacoDaMateria)
	# Apaga objeto original, que era usado só pra marcar o espaço.
	scribus.deleteObject(espacoDaMateria)

	# Cria um bloco de texto com as medidas extremas do objeto
	# E deleta o objeto (que pode ser até uma linha)
	quadroDeTitulo = scribus.createText(esquerdaDoQuadro, topoDoQuadro, larguraDoQuadro, alturaDoQuadro)

	# Pergunta pelo número de colunas
	numeroDeColunas = pedeNumeroDeColunas()

	# Pergunta pelo espaço entre-colunas
	entrecolunas = pedeEntrecolunas()

	# Pergunta pelo tamanho do título em pontos
	corpoDeTitulo = pedeCorpoDoTitulo()

	# Pergunta pelo tamanho do antetítulo
	corpoDoSobretitulo = pedeCorpoDoSobretitulo()

	#######################################
	# TÍTULO
	#######################################
	# Calcula o tamanho total dos títulos
	alturaDoQuadroDeTitulo = (corpoDeTitulo + corpoDoSobretitulo) * proporcaoDeEntrelinha
	direitaDoQuadro = esquerdaDoQuadro + larguraDoQuadro
	# Redimensiona quadro de título
	scribus.sizeObject(larguraDoQuadro, alturaDoQuadroDeTitulo, quadroDeTitulo)
	# Define o tipo de fluxo de texto: "afastar texto"
	flow(quadroDeTitulo, AROUND_FRAME)

	#######################################
	# COLUNAS DE TEXTO
	#######################################
	# Define medidas do quadro de textos
	topoDasColunas = topoDoQuadro + alturaDoQuadroDeTitulo
	alturaDasColunas = alturaDoQuadro - alturaDoQuadroDeTitulo
	# Cria quadro de texto
	quadroDeColunas = scribus.createText(esquerdaDoQuadro, topoDasColunas, larguraDoQuadro, alturaDasColunas)
	# Define o fluxo de texto como "afastar texto"
	flow(quadroDeColunas, AROUND_FRAME)
	# Determina colunagem
	scribus.setColumnGap(entrecolunas, quadroDeColunas)
	scribus.setColumns(numeroDeColunas, quadroDeColunas)

	#######################################
	# LINCA TEXTOS
	# Linca quadros de título e de texto
	#######################################
	scribus.linkTextFrames(quadroDeTitulo,quadroDeColunas)
	storyGroup = scribus.groupObjects([quadroDeTitulo, quadroDeColunas])

	#######################################
	# PEGA TEXTO
	#######################################
	# Quadro de escolha de arquivo
	text = pedeTexto(quadroDeTitulo)

	try:
		#scribus.insertText(text,-1,quadroDeTitulo)  # para ANEXAR ao final em vez de substituir
		scribus.setText(text,quadroDeTitulo)
	except:
		text="SobretítulonTítulonAutor da matérianComplemento ao autornPrimeiro ParágrafonOutros parágrafosOutros parágrafos..."
		scribus.setText(text,quadroDeTitulo)

	#######################################
	# PEGA FOTO
	#######################################
	# Ask image
	temImagem = pedeImagem()
	if temImagem:
		montaQuadroDaFoto(quadroDeColunas)

def manipulaSelecao():
	""" Gerencia objetos selecionados """

	# Pega o objeto selecionado
	story = scribus.getSelectedObject(0)
	# Se há apenas um objeto selecionado
	if story and scribus.selectionCount() == 1 :
	#	if story:
		montaMateria(story)
		scribus.docChanged(True)
	else:
		#Melhoria pra o futuro:
		#por default, abrir uma matéria do tamanho da página
		# De momento, só avisa
		scribus.messageBox(
			labelDeQuadroDeTitulo,
			pedirParaAbrirQuadro,
			ICON_WARNING,
			BUTTON_OK
		)

def manipulaDocumento():
	"""Manipula documentos """
	# Se há documento aberto
	if scribus.haveDoc():
		#Desliga redraw
		scribus.setRedraw(False)
		#Guarda unidades do usuário # Save unit
		unit = scribus.getUnit()
		#Define novas unidades como "pontos tipográfico"
		scribus.setUnit(UNIT_POINTS)

		#############################
		# Manipula objeto selecionado
		#############################
		manipulaSelecao()

		#Recupera medidas do usuário
		scribus.setUnit(unit)
	else:  # Senão há documento aberto, avisa.
		scribus.messageBox(
			labelAbreDoc,
			dizAbreDoc,
			ICON_WARNING,
			BUTTON_OK
		)

def myCode():
	""" User code """
	#########################
	#  USER CODE GOES HERE  #
	#########################

	# Gerencia documento
	manipulaDocumento()

	#########################
	#  USER CODE ENDS HERE  #
	#########################

def main(argv):
	"""Default main entry point"""
	myCode()

def main_wrapper(argv):
	try:
		scribus.statusMessage("Rodando o script...")
		scribus.progressReset()
		main(argv)
	finally:
		if scribus.haveDoc():
			scribus.setRedraw(True)
		scribus.statusMessage("")
		scribus.progressReset()

if __name__ == '__main__':
	main_wrapper(sys.argv)

Bibliografia

1. ROSSUM, Guido Van. Python Tutorial. Capítulo 4, More control flow tools, FOR statements. Site web disponível em: <http://www.python.org/doc/2.4.4/tut/node6.html#SECTION006200000000000000000>. Acesso em 25. jul. 2008.
2. SCRIBUS. Arquivo de ajuda. Versão 1.3.3.12. Capítulo For Developers, seção Scripter API, página Page Comands. Disponível no programa através da tecla F1.

Coloque as linhas abaixo num arquivo-texto com o nome de caps2shift.reg (o nome não é importante, só o .REG). Grave, dê dois clics no arquivo para incluir os comandos no registro do Windows (confirme que vai incluir no registro, quando o Windows perguntar). E pronto: a tecla CAPS LOCK foi transformada em SHIFT, a partir do próximo boot.

Este é o código que muda o registro do Windows para trocar a tecla CAPS LOCK (trava das maiúsculas) por uma coisa mais inócua:

Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Keyboard Layout]
"Scancode Map"=hex:00,00,00,00,00,00,00,00,02,00,00,00,2a,00,3a,00,00,00,00,00

Os códigos em hexadecimal significam o seguinte (códigos menores vêm primeiro, o chamado little endian):

Para desfazer a gambiarra, apague a chave “Scancode Map” (que não existe normalmente) através do programa editor de registro regedit.

Para transformar o CAPS LOCK em SHIFT e transformar a tecla WINDOWS LOGO da esquerda em ALT esquerdo (útil para evitar erros em joguinhos), use o código:

Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Keyboard Layout]
"Scancode Map"=hex:00,00,00,00,00,00,00,00,03,00,00,00,38,00,5b,e0,2a,00,3a,00,00,00,00,00

Bibliografia

• Archive: Scan code mapper for Windows. Página na Microsoft que explica o procedimento.

No Brasil, já surgem anúncios do Eee PC por 799 reais (com mouse e bolsa). Aparentemente, há liquidação de estoques quando se espera o lançamento do Eee PC de tela de 9 polegadas e mais memória. E a queda de preço vai continuar: Mary Lou Jepsen prevê a inundação do mercado por cerca de 50 modelos ultraportáteis, a partir da Computex 2008, em Taiwan.

Mary Lou Jepsen, umas das 100 pessoas mais influente do mundo na atualidade, segundo a revista Time, também prevê o lançamento de novos gadgets e novas tecnologias de tela de TFT-LCD, já que as fábricas chinesas saturaram o mercado com TVs LCD e precisam produzir desesperadamente, pois têm custos muito altos. Ela está atuando junto aos fabricantes para novos produtos. Para os próximos dois anos, podemos esperar melhores leitores de livros, DVDs portáteis e celulares que podem ser usados à luz do sol.

E tem gente que ainda acha que o OLPC fracassou…

Saiba mais no log de Ms. Jepsen.

Depois de muita pesquisa na rede e muitos testes errados, consegui instalar rede sem fio no meu novo laptop Acer 4520 com Ubuntu 8.04 64 bits. Usei o seguinte esquema:

1. Desativei os drivers proprietários que o Ubuntu instalou por default (Sistema > Administração > Drivers de Hardware, desmarquei os dois drivers Atheros).
2. Para me certificar que os drivers Atheron velhos não seriam carregados, num terminal digitei

   sudo gedit /etc/modprobe.d/blacklist

   e inseri no final do arquivo de “lista negra de drivers” o texto

   blacklist ath_pci

3. Dei reboot.
4. Usando conexão por cabo ethernet, instalei o Instalador de Drives Wifi (Aplicações > Adicionar/Remover, procurei por wifi). Ele já instalou o empacotador Ndiswrapper. O Ndiswrapper é um pacote de software que “embrulha” os drivers originais para Windows das placas Atheros, e os faz trabalhar no Linux, já que a Atheros não desenvolveu o driver nativo para o pinguim. O programa Windows Wireless Drivers facilita a instalação do Ndiswrapper.
5. Baixei os drivers Atheros para Windows 64 bits no site Checo da Atheros. Entre os diversos drivers desta página, o que funcionou foi a versão 5.3.0.56 para Windows XP 64 bits.
6. Abri o zip numa pasta. Usei o programa instalador (que, depois de instalado, ficou em Aplicações > Ferramentas do Sistema > Instalar drives wifi ) para procurar o arquivo .inf dos drivers e mandei instalar.
7. Desliguei o cabo da placa ethernet. O wifi conectou.
8. Drawbacks: a luzinha do wifi não acende no Ubuntu 64 bits, só no 32 bits. Por isso, se a conexão não está funcionando, aperto o botão do wifi e espero um pouco. Se tudo estiver OK, o ícone do wifi na barra superior começa a girar, fazendo a conexão.
9. Infelizmente, depois do reboot, o wifi não consegue conectar. Depois de um minuto, pede novamente a senha wifi. Eu forneço corretamente, ele fica tentando autenticar por um minuto e volta a pedir a senha. Por que quando da instalação o driver autentica logo e depois, não? Sem senha, o wifi conecta em segundos. Mas não sou doido de usar minha rede wifi sem senha…

Conclusão

Voltar a usar Ubuntu 32 bits. O mundo não está preparado para 64 bits. O driver de Scanner HP Scanjet 2400 também só funciona em 32 bits.

Saiba mais

• Adeus ao ndiswrapper. Você pode tentar estas dicas.
• Support for AR2425 (AR5007EG) chipset. Site dos drivers Madwifi. É aqui que estão as novidades sobre os drivers para o Atheros.

Bibliografia

1. Acer 4520 complete guide (almost), do brasileiro Felipe. Thx, Felipe! Grande trabalho você fez para a comunidade!
   

Resumindo: os documentos Microsoft continuarão sendo mal convertidos por outros programas (Koffice, AbiWord, OpenOffice, WordPerfect), e os desenvolvedores que usarem-nos poderão ter que pagar royalties, coisa impensável para normas ISO. Mas a empresa poderá vender programas para governos dizendo que são “ISO standards”.

Um exemplo do que é o formato OOXML: as datas só funcionam bem se você fizer de conta que existiu o dia 29 de fevereiro de 1900, o famoso dia de São Nunca. Isto não é um 1º de abril.

Na época, março de 2008, paguei R$ 1.899,00 por um laptop Acer Aspire com os requisitos que buscava:

• Som Dolby com saída S/PDIF 5.1 (por fio metálico, não por fibra óptica). Embora com apenas dois alto-falantes, as melhorias Dolby deixam as saídas sonoras com boa qualidade. O laptop tem entrada de linha estéreo, entrada de microfone e uma saída para o fone de ouvido ou S/PDIF. O dial circular de volume de som é digital, enviando um sinal de tecla para aumentar ou diminuir o som.
• HD de 160 MB, para colocar bastantes sistemas operacionais diferentes.
• Processador AMD Turion 64 de 2200 MHz
• 2 GB de memória RAM (o distribuidor InfoHelp colocou 1GB além do GB de fábrica).
• Gravador de CD/DVD 12x.
• Webcam VGA integrada. Com 640×480 pixels, microfone embutido, 30 fps.
• Leitor de cartão de memória SD e MemoryStick e ExpressCard/54
• Entradas/saídas para rede Ethernet, Wifi, FireWire, 4 USB, modem telefônico, Bluetooth e infravermelho.

Por este preço, naturalmente não estava incluído o sistema operacional. Ou melhor: ele veio com um Linux básico, limpo, convenientemente chamado de Linpus (hehe). Coisas de Taiwan.

Embora seja planejado para o Windows Vista, o Acer Aspire 4520 vem com um CD com drivers para Windows XP (já que muita gente troca Vista por Windows XP). Assim, foi fácil instalar minha licença Windows XP e colocar tudo para funcionar. Só fiquei sem os programas utilitários para ajustar as características do aparelho que vem na versão com Vista já instalado.

O maior trabalho foi para instalar junto o Ubuntu 7.10. Como se deve fazer, corri para os fóruns da internet. Achei o artigo Acer 4520 Complete Guide (or Almost), feito pelo Felipe Pinheiro.

Felipe compilou todas as receitas para instalar o Ubuntu no Acer Aspire 4520. Em outros artigos comento como obtive sucesso em instalar o Ubuntu com todos os recursos do Acer Aspire 4520.

O resultado é o barateamento dos laptops e desktops e maior inclusão digital. É o caso do computador educacional da VocalTech, um modelo bem equipado por R$ 718,32 (416 dólares), um preço inacreditável para o mercado brasileiro. Monitor de 17 polegadas, memória de 512 MB, disco de 80 GB, entregue em casa e com frete incluso pelo Pac Correios.

A ficha completa é esta:

• Gabinete Torre, cor preta
• Placa-Mãe MATX A13G Soquete AM2 – PC Chips (ou similar)
• Processador AMD Sempron LE1100 AM2 (ou similar)
• 512 Mb RAM (Suporte a 2x DDR2 800/667/533/400 (2GB RAM)
• 80GB Disco Rígido Sata
• Combo Gravador CD + Leitor DVD
• 1PCI-Express (16x), 1 PCI-Express (1x), 2PCI, 1 CNR
• 4 USB 2.0, 1 IDE, 2 SATA II 3.0GBs
• Monitor CRT 17 polegadas
• Garantia de 12 meses, suporte via call center de 12 meses.

VocalTech é uma pequena empresa tocada por oito sócios do Espírito Santo, entre eles Antonio Dettmann, um militante do software livre e antigo desenvolvedor brasileiro do PHP-Nuke. Com esse agressivo marketing baseado no preço, a empresa pretende, em um ano, ter 50 funcionários, e dará preferência a deficientes físicos que possam trabalhar em linha de montagem.

A VocalTech conseguiu esta façanha usando hardware compatível com Linux, “hardware padrão sem grandes firulas”, diz Dettmann. Além da distribuição, também terceirizaram o suporte, através da distribuição brasileira ProLinux (baseada em Debian), que forneceu o sistema operacional Linux para o Pró-Jovem do MEC.

O press release da empresa termina com uma citação do prof. Pietro Ubaldi:

“O próximo grande salto evolutivo da humanidade será a descoberta de que cooperar é melhor que competir”

Fica aqui registrada, então, minha cooperação divulgando o case de mercado para ajudar a empresa a contratar mais deficientes físicos e a colaborar com a inclusão digital.

Mesmo o Tétum não é a língua mais falada, mas foi adotada na liturgia pela igreja católica, já que o português havia sido proibido pela ditadura militar indonésia. Assim, transformou-se em língua franca, principalmente o tetum-prasa (tétum-praça), dialeto falado na capital Díli com tantas palavras em português que é quase um crioulo.

Como me interesso pela comunidade lusófona, passei a acompanhar mais de perto a situação do Timor-Leste depois de um embroglio que resultou no presidente Ramos-Horta baleado, dois militares rebeldes mortos e um segurança presidencial seriamente ferido. Para entender melhor a situação, às vezes expressa em tétum, baixei um dicionário Tétum-Português-Indonésio em formato PDF, compilado por Ken Westmoreland.

Mas consultar um dicionário de papel é chato, mesmo em PDF. Melhor seria usar um programa como o Babylon Translator, um dos poucos programas comerciais que valem a pena ser comprados. Ainda mais agora, com o dólar “derretendo” no Brasil. O Babylon Translator traduz rapidamente uma palavra quando você control-clica em cima dela. Isso funciona mesmo em palavras em imagens, porque o programa faz um OCR (reconhecimento de caracteres) antes de traduzir. Também fornece a pronúncia robotizada de palavras em inglês.

Dica: se você tiver cartão de crédito internacional, no Brasil compre em dólar, não em real, que deixa o produto mais caro. Pra mim, com a Brittanica resumida, saiu por 71 dólares. Mas você também pode baixar o Babylon para testes durante 30 dias.

Baixado o Babylon Translator, me dediquei a construir um dicionário tétum para ele, o que exigiu pesado processamento de texto. Transformei o PDF em texto. Editei o texto no BROffice e no Notepad++ inserindo tabulações entre as palavras tétum, portuguesas e indonésias. Também inseri o gênero feminino nas palavras de origem portuguesa do tétum, além de mudar a ordem das designações de classes das palavras. Tudo isto graças ao recurso de procura-e-troca com expressões regulares, um recurso informático meio complicado mas poderosíssimo.

Preparado o texto, gravei como “texto-separado-por-tabulação” e importei numa planilha eletrônica do BROffice, que gravei como formato MS Excel. Aí, pude criar o dicionário com o Babylon Builder, programa gratuito distribuído pela empresa para que os usuários criem vocabulários e dicionários.

Para colocar uma cereja no bolo, criei com o IrfanView um ícone com a bandeira do Timor-Leste a partir da bandeira do país na Wikipedia e usei no Builder.

Se você precisar urgentemente de um dicionário Tétum-Português-Indonésio para o Babylon Translator, baixe aqui. E se você quiser ajudar colocando mais palavras neste dicionário, use a versão Google Planilha que coloquei na rede. Basta pedir permissão para editar. O copyright do dicionário é de Ken Westmoreland (sob o pseudônimo Buka Hatene, que significa “aprender”, em tétum).

• Baixe o Dicionário Tétum-Português-Indonésio para Babylon Translator
• Baixe o dicionário Tétum-Português-Indonésio de Ken Westmoreland (Buka Hatene) em PDF

(O título deste post é uma citação ao conto “O Homem que falava Javanês“, do escritor brasileiro mestiço Lima Barreto).

1. Ela perdeu o bonde da história. Hoje, ferramentas digitais são quase todas gratuitas ou pela Web. A MS ainda não entendeu isso.
2. É uma empresa anti-ética, que abusa do poder econômico monopolista e tem práticas desleais de mercado.
3. Somos um país pobre. Não recomendo a ninguém, pessoa física ou jurídica, pagar 2.300 reais por uma suíte de escritório, quando alternativas custam zero reais como o OpenOffice (BRoffice) e fazem exatamente a mesma coisa, com raríssimas excessões (algumas planilhas gigantescas, p. ex.).
4. É uma empresa que se sustenta não pela geração de riquezas, mas sugando a riqueza de outros através de preços artificialmente elevados pelos monopólios de copyright e patentes, garantido pelo estado.
5. Os produtos dela são reconhecidos pela falta de segurança e descuido intencional de programação.
6. Os produtos dela são atualizados sem necessidade, obrigando o consumidor a comprar novos hardwares ou softwares para fazer as mesmas tarefas que antes.

Por outro lado, recomendo sistemas da Google por estas razões:

1. É uma empresa ética e responsável. Tem um comitê de ética que analisa todos os lançamentos.
2. Vive da geração de riqueza. O modelo de negócios através de anúncios funciona porque os anúncios funcionam, gerando negócios para os anunciantes. O anunciante só paga se o anúncio funcionar, permitindo maior eficiência em verbas publicitárias e diminuindo o preço de produtos ou serviços.
3. A Google dá bastantes serviços para a rede gratuitamente, assim como a rede dá faturamento para a Google.
4. É inovadora e criativa, e sabe valorizar novos negócios.
5. Entendeu perfeitamente o “espírito” da rede digital.
6. Respeita seu usuários, diferentemente do Yahoo, que “entregou” um jornalista chinês, hoje condenado a 10 anos de prisão.

Também recomendo software livre e aberto por estas razões:

1. Evoluem mais facilmente que produtos proprietários.
2. Permitem mudanças para se adaptarem aos interesses de cada empresa.
3. Suas falhas de segurança são rapidamente consertadas.
4. São gratuitos.
5. Não geram uma economia desequilibrada e injusta, como os softwares proprietários.
6. Trabalham com formatos abertos e públicos, como Open Document.

Mas segundo a profª Léa Fagundes, do LEC da Ufrgs e participante do projeto UCA, a nova pedagogia poderá ser aplicada com qualquer máquina que vencer a licitação.

Para mim, o mais grave será, possivelmente, a falta de roteamento da rede mesh. É muito provável que ele só terá capacidade de participar da rede mesh como cliente. Junte a isto uma provável placa de rede WiFi de alcance standard (uns 40m), e isto matará a inclusão digital das famílias dos alunos: ficará tremendamente difícil acessar a internet pela rede das escolas.

Mas este panorama poderá mudar se a Intel e a Positivo tiverem, em dois meses, implementado uma tecnologia mesh como a OLPC e a Marvell estão desenvolvendo há dois anos: mesh com roteamento mesmo com a máquina dormindo, placas WiFi com 200 metros de alcance (1300m sem barreiras).

Outro ponto negativo será no gasto de energia elétrica: o Classmate, por ser mais potente e de uma tecnologia mais antiga de processador e tela, gasta mais. Este custo ficará escondido nas contas de energia das escolas, mas é significativo ao longo de cinco anos de vida útil do equipamento. A diferença de gasto de energia pode chegar de 70 a 100 reais, entre a classe de laptops Classmate e a classe XO. O XO gasta a metade da energia de um Classmate, ou menos ainda.

No boot, mantendo-se pressionadas as teclas CMD-ALT-O-F, entra-se no OpenFirmware, um interpretador de linguagem Forth. Detalhes no Feedface. Não sei se os novos MacIntel fazem isto.

Forth é uma linguagem de alto nível, poderosíssima, ideal para hackers. Tipo o Basic de antigamente, só que muuuuitas vezes melhor. Trabalha com qualquer base numérica (de 2 a 72), tem matemática tipo HP-12C. Deu origem ao PostScript, por exemplo.

Agora, o mesmo esquema do Mac está sendo usado no laptop XO do projeto OLPC. Neste, o OpenFirmware substituiu o BIOS e o bootloader Linux. Interrompendo-se o boot, entra-se no interpreetador Forth e pode-se até mesmo desenhar pixels coloridos no frame-buffer da maquininha (memória de vídeo).

Com tempo, disposição e sem namorada, um guri pode fazer um sistema operacional gráfico a partir do nada.

(Mas tô delirando… Quando é que um guri vai poder fazer um sistema operacional from the grassroots?

Só que precisamos mais. Precisamos de uma democracia 100%. Precisamos de uma democracia direta, em que a gente vote diariamente sobre tudo, como se votasse no paredão do bigbróder. Por telefone, por internet, por web, por email. A gente chega, escolhe os projetos em votação, vota e espera o resultado.

Isto é possível agora. Neste instante, o Brasil domina a tecnologia de votação e pode fazer muito melhor. Em cada aldeia pode haver uma urna ligada por satélite, movida a cata-vento ou energia solar, enviando a votação diária do pessoal. Os projetos Gesac e Um Computador por Aluno podem ser ampliados para que todo o Brasil seja coberto por redes sem fio, e para que todos os brasileiros possuam um laptop portátil, tão pessoal quanto carteira de identidade.

Não precisamos mais dos políticos profissionais. Já está mais do que provado que democracia representativa está obsoleta. Todos nós somos políticos, e temos que votar diretamente todos os dias sobre todos os assuntos.

Mas como descobrir se o firewall ou roteador estão bloquando portas? Quais as portas estão bloqueadas?

Um dos melhores serviços para descobrir isto é o site da Gibson Research Corporation, que é umas daquelas corporações um só homem. Se acessar o site GRC pela página principal, role a tela um pouco para achar o link ShieldsUP!. Veja os tipos de testes que se pode fazer.

Na tela que aparece, role um pouco e clique no botão “Proceed”. Se seu browser avisar sobre site inseguro ou algo parecido, clique em “continuar”. Agora, você estará na página de testes. Existem diversas opções de uso. Você pode testar portas individuais — uma a uma, ou uma faixa de 64 portas. Também pode testar as primeiras 1056 portas, chamadas de portas de serviços. A figura mostra o resultado deste teste, mostrando todas as portas fechadas, menos a do protocolo kerbelos. O router Dlink DI-624 com firewall fez este bloqueio.

Para desbloquear todas as portas e deixar um computador com acesso total à internet (o que pode ser um furo de segurança), você pode configurar o firewall do router DI-624 para colocar a máquina numa “zona desmilitarizada”. Isto é feito conforme indica a ilustração. Descubra o IP da máquina na rede interna, coloque no formulário e aplique a mudança.

A seguir, faça novamente o teste no GCR. Verifique o resultado. As portas de serviço apresentam um comportamento estranho. Algumas aparecem escondidas (cor verde) enquanto outras aparecem abertas (azul). Se você fizer outro teste, o padrão vai mudar. Isso se deve ao firewall do seu provedor (neste caso, da Net Virtua). O firewall deles apresenta um “comportamento adaptativo”, escondendo e liberando portas aleatoriamente, para evitar ataques.

Algumas portas são sempre bloqueadas pelos provedores, para cobrar mais caro dos clientes. Por exemplo, a porta 80, de servidores Web e a porta 21, de servidores de FTP. O remédio é usar outras portas abertas, como 8080 e 8021, para estes serviços. A porta 443 é sempre aberta, porque é usada paor servidores Web seguros, para compras etc. Se ela fosse fechada, a internet morreria.

Também chamam de ciber-isso, ciber-aquilo. Internet tem algumas coisas de cibernética, na forma de netiqueta, regras de comportamento online e câmeras de controle remoto. Mas cibernética não é a característica principal da internet.

Tampouco a internet é virtual, porque apenas adiciona algumas camadas de mediação nas interações “ao vivo”, que já são mediadas pela luz e pelo ar. O fato de se criarem mais algumas mediações não cria um mundo novo, “virtual”, diferente do mundo real. Internet é tão “vida real” quanto a vida real.

Finalmente, não é digital, porque dígitos são números, e computadores têm poucas coisas numéricas. A maior parte dos dados são instruções para o processador. E existem dados que representam cores, música etc, não números. Na fundo, essa é uma tecnologia lógica. A internet, então, é uma rede de lógica binária, para dar nome e sobrenome.

Atari, Pong, Breakout, Apple e como a HP perdeu a chance de inventar os microcomputadores.

Confira as fórmulas usada na planilha.

Conclusões:

1. A impressão mais barata é em impressora laser.
2. A impressora laser colorida só custa 2,5 vezes mais caro que a impressão em preto-e-branco.
3. A impressão a jato-de-tinta é a mais cara, o dobro do preço da impressão a laser, que tem muito mais qualidade.