CS Fundamentals Trainer · Guias

Identificadores persistentes e link rot

Por que uma URL falha como nome, como um DOI é construído e resolvido, como normalizar e verificar identificadores (medido: ISBN-13 e ORCID detectam erros de digitação, DOIs não), por que um 301 quebra atualizações em um navegador real, negociação de conteúdo e regras para projetar seus próprios identificadores.

20 min de leitura

Um endereço web faz dois trabalhos ao mesmo tempo: nomeia uma coisa ("este artigo") e diz onde essa coisa está hoje ("este servidor, este caminho"). Isso funciona até o local mudar. Uma universidade muda o seu site, uma editora troca de plataforma, uma empresa é adquirida, e todo link que usava o local antigo passa a levar a uma página de erro. Os identificadores persistentes são a solução: um nome que permanece o mesmo enquanto o local por trás dele pode mudar. O DOI (Digital Object Identifier) de um artigo científico é o exemplo mais conhecido, e as ideias valem para qualquer sistema que distribui nomes que as pessoas vão guardar por anos. Este guia explica o problema, como um DOI é construído e resolvido, por que os dígitos verificadores importam (e por que os DOIs não têm um) e o que copiar ao projetar identificadores próprios. O guia complementar, Projetando um resolvedor de DOI, constrói o serviço que responde às consultas.

1. O problema: um nome que também é um endereço

Três palavras descrevem como os links falham:

Quão comum é isso? Um grande estudo de artigos acadêmicos (Klein e colegas, 2014, com mais de 1 milhão de referências a recursos web extraídas de mais de 3,5 milhões de artigos) encontrou que um em cada cinco artigos de ciência, tecnologia e medicina sofria de reference rot, e cerca de sete em cada dez entre os artigos que citam recursos web [1]. Esses números são para referências web, não para DOIs, e descrevem 2014; trate-os como a ordem de grandeza do problema, não como uma taxa atual.

O conselho de Tim Berners-Lee, "Cool URIs don't change" [2], está certo, e também é o que falha na prática: as organizações se reorganizam, e um caminho que era um bom nome no ano passado vira um link quebrado. A resposta robusta não é prometer que os endereços nunca mudarão, mas parar de usar o endereço como nome.

2. A ideia: separar o nome do local

Acrescente um nível de indireção. Publique e cite um nome estável; mantenha uma tabela que mapeia o nome para o local atual; quando o local muda, atualize uma linha da tabela, e todas as citações continuam funcionando.

Diagram: A stable name, resolved to a location that can move

A indireção move o problema; não o elimina. Alguém precisa manter a tabela atualizada. Um DOI que aponta para uma página morta ainda é um link quebrado, e só a organização que o registrou pode consertá-lo, então a persistência é um compromisso social e contratual apoiado por software, não uma propriedade da string. O que o software lhe dá é que a correção é uma atualização em um só lugar, em vez de pedir a cada autor que cita que edite cada documento.

3. Como um DOI é construído

Um DOI tem duas partes separadas pela primeira barra:

10.1145 / 362686.362692
└──┬──┘   └─────┬──────┘
 prefix      suffix
DOIO que nomeia
10.1145/362686.362692O artigo de Bloom de 1970 sobre hash coding (citado no guia do crawler)
10.1145/509907.509965O artigo de Charikar por trás do simhash
10.1371/journal.pone.0115253O estudo de reference rot acima
10.1016/S0169-7552(98)00110-XUm sufixo "estruturado" mais antigo: carrega o ISSN de uma revista, um ano de dois dígitos, um número de item e um caractere verificador final, e usa parênteses

Por baixo, o sistema DOI usa o Handle System (as RFCs 3650 a 3652 descrevem sua arquitetura, espaço de nomes e protocolo [3]): um serviço global que resolve um handle encaminhando seu prefixo ao serviço que guarda os registros desse prefixo. O DOI é um padrão por si só (ISO 26324). Diferentes agências de registro cuidam dos registros de diferentes tipos de conteúdo; a Crossref registra a maioria dos artigos e livros acadêmicos, e a DataCite é a agência comumente usada para conjuntos de dados e software. A agência também guarda os metadados (título, autores, data, licença) ao lado do local.

Para exibição, a convenção é mostrar um DOI como um link completo, https://doi.org/10.1145/362686.362692, para que seja clicável e inequívoco. A forma 10.… pura é para bancos de dados.

4. Normalizando: uma chave para cada DOI

Tudo que armazena ou compara DOIs (uma ferramenta de bibliografia, uma verificação de duplicatas, um resolvedor) precisa de uma chave canônica. As pessoas digitam e colam DOIs de muitas formas: com https://doi.org/, com o antigo host dx.doi.org, com doi:, em maiúsculas, com percent-encoding, com um ponto do fim de uma frase grudado. A regra é remover o invólucro, decodificar, converter para minúsculas e verificar o formato:

import re
from urllib.parse import unquote

DOI = re.compile(r"^10\.\d{4,9}/\S+$")          # a loose shape check, not a validity check

def normalise_doi(s):
    s = s.strip()
    s = re.sub(r"^(?:https?://(?:dx\.)?doi\.org/|doi:\s*)", "", s, flags=re.I)
    s = unquote(s)
    return s.lower() if DOI.match(s) else None

Executei isso nestas entradas:

EntradaNormalizada
https://doi.org/10.1145/362686.36269210.1145/362686.362692
HTTP://DX.DOI.ORG/10.1145/362686.36269210.1145/362686.362692
doi: 10.1145/362686.36269210.1145/362686.362692
10.1016/S0169-7552(98)00110-X10.1016/s0169-7552(98)00110-x
https://doi.org/10.1016/s0169-7552%2898%2900110-x10.1016/s0169-7552(98)00110-x (as duas grafias se encontram em uma chave)
not a doi, 10.12/shortNone (rejeitadas)

Duas ressalvas. Primeiro, o problema da pontuação final é real: ao extrair DOIs de texto corrido, um . ou ) final pode ou não fazer parte do sufixo, porque os sufixos podem legitimamente terminar em ambos. Remova um ., , ou ; final quando o texto for prosa e, na dúvida, consulte o candidato em vez de adivinhar. Segundo, converter para minúsculas é certo para comparação; para exibição, mantenha o que o registrante publicou.

5. Verificando identificadores: dígitos verificadores, e por que os DOIs não têm

Um dígito verificador é um caractere calculado a partir dos outros, de modo que um erro de digitação faça a verificação falhar. O ISBN-13 usa uma soma ponderada módulo 10; o ORCID iD (o identificador usado por pesquisadores) termina com um caractere calculado com ISO 7064 MOD 11-2, em que o valor 10 é escrito X [4]. O algoritmo do ORCID em código:

def orcid_check_digit(first15):
    total = 0
    for ch in first15:
        total = (total + int(ch)) * 2
    r = (12 - total % 11) % 11
    return "X" if r == 10 else str(r)

def orcid_ok(s):
    s = s.replace("-", "")
    return len(s) == 16 and s[:15].isdigit() and orcid_check_digit(s[:15]) == s[15]

def isbn13_ok(s):
    d = [int(c) for c in s if c.isdigit()]
    return len(d) == 13 and sum(x * (1 if i % 2 == 0 else 3) for i, x in enumerate(d)) % 10 == 0

Os exemplos conhecidos passam (978-0-306-40615-7 e a identidade de teste documentada do ORCID, 0000-0002-1825-0097), e as mesmas strings com o último dígito alterado falham. Depois perguntei quão bem cada esquema percebe erros, com 100 000 identificadores aleatórios cada:

EsquemaUm dígito errado detectadoDois dígitos adjacentes trocados, detectado
ISBN-13100,00%90,97%
ORCID iD100,00%100,00%

Ambos pegam todo erro de um único dígito. A troca de vizinhos é onde diferem: no ISBN-13, a troca de dois dígitos que diferem por 5 deixa a soma inalterada (os pesos são 1 e 3, então a mudança é um múltiplo de 10), de modo que cerca de uma troca em dez passa (9% na minha execução); o MOD 11-2 pega toda troca.

Um DOI não tem dígito verificador. Seu sufixo é o que o registrante escolheu, então não há nada a calcular. A verificação de formato acima aceitou 20 000 de 20 000 mudanças de um único dígito em um DOI real: um erro de digitação produz outro nome sintaticamente válido, e a sintaxe não consegue distingui-lo de um artigo diferente. A única verificação confiável é resolvê-lo (perguntar ao resolvedor se o nome existe) ou consultar seus metadados e comparar o título. É também por isso que copiar e colar um DOI em um manuscrito é mais seguro que redigitá-lo.

Lição de projeto para seus próprios identificadores: se as pessoas vão digitá-los ou lê-los em voz alta (um número de pedido, um código de rastreamento, um id de associado), acrescente um caractere verificador; o custo é um caractere e ele elimina a maioria dos erros de digitação. Se são máquinas que os movem (links, ids de API), um dígito verificador acrescenta pouco e uma consulta é a validação real. Um dígito verificador não é um recurso de segurança: qualquer um pode calculá-lo.

6. O resolvedor não deve ser cacheado para sempre

Um resolvedor responde com um redirecionamento. Qual redirecionamento importa, porque navegadores e intermediários fazem cache de alguns deles. Iniciei um pequeno servidor que redirecionava /r/x para /a, visitei-o em um Chromium real, movi o destino para /b e visitei o mesmo endereço de novo no mesmo navegador:

RedirecionamentoCache-ControlDepois que o destino mudou, a segunda visita foi paraO resolvedor viu a segunda visita?
301nenhum/a (errado)não, respondido pelo cache do navegador
308nenhum/a (errado)não
302nenhum/bsim
307nenhum/bsim
301no-store/bsim
301max-age=60/a (errado por até um minuto)não
302max-age=60/a (errado por até um minuto)não

Um redirecionamento permanente (301, 308) é cacheável por padrão e, sem informação de frescor, os navegadores o mantêm pelo tempo que quiserem [5]. Para um mapeamento que deve mudar (esse é todo o objetivo de um identificador persistente), um redirecionamento permanente em cache vira a promessa do resolvedor de cabeça para baixo: leitores que visitaram uma vez continuam indo ao local antigo depois que o publicador se mudou. Então um resolvedor responde com um redirecionamento temporário (302 ou 307) e escolhe seu cache de propósito com Cache-Control: uma vida curta troca um pouco de obsolescência por muito menos requisições.

7. Um nome, várias representações: negociação de conteúdo

O mesmo DOI pode ser pedido em formatos diferentes. Um navegador envia Accept: text/html e é redirecionado para a página da editora; um gerenciador de referências envia outro valor de Accept e recebe metadados. A documentação da Crossref lista estes valores para requisições enviadas ao resolvedor de DOI [6]:

Cabeçalho AcceptVocê recebe
application/vnd.citationstyles.csl+jsonCSL JSON (o que a maioria das ferramentas de citação lê)
application/x-bibtexBibTeX
application/x-research-info-systemsRIS
text/x-bibliographyuma citação formatada
application/rdf+xml, text/turtleRDF
application/vnd.crossref.unixref+xmlO XML da Crossref
curl -L -H "Accept: application/vnd.citationstyles.csl+json" https://doi.org/10.1145/362686.362692
curl -L -H "Accept: application/x-bibtex" https://doi.org/10.1145/362686.362692

O -L importa: o resolvedor descobre qual agência de registro guarda o registro e redireciona a requisição para lá, então um cliente que não segue redirecionamentos vê apenas o redirecionamento.

Um detalhe de HTTP para lembrar: quando a mesma URL dá respostas diferentes dependendo de um cabeçalho da requisição, os caches precisam ser avisados, com Vary: Accept, ou um cache compartilhado servirá BibTeX a um navegador. O guia de estratégias de cache cobre o Vary.

8. Outras formas de nomear coisas

IdentificadorO que éCaractere verificadorResolvido por
DOInome de um objeto publicado; sufixo escolhido pelo registrantenãodoi.org (Handle System)
ORCID iDnome de uma pessoa (um pesquisador)sim (MOD 11-2)orcid.org
ISBN-13nome de uma edição de um livrosim (mod 10)nenhum resolvedor único; catálogos
UUID (v4)nome aleatório de 122 bits, sem significadonãonada; é apenas único
URL simplesnome e endereço em um sónãoDNS e o servidor web
Snapshot de arquivouma cópia do conteúdo em uma datan/aum arquivo (por exemplo o Internet Archive)

Duas estratégias diferentes se escondem nessa tabela. A indireção (DOI, ORCID) mantém o nome estável e atualiza para onde ele aponta. A preservação (um snapshot de arquivo) guarda uma cópia do próprio conteúdo, de modo que a citação sobrevive mesmo que a fonte desapareça. Elas resolvem falhas diferentes: a indireção não ajuda se a editora fecha e ninguém atualiza o registro; um snapshot não ajuda se você quer a versão viva e atual. A escrita acadêmica cuidadosa usa as duas.

9. Projetando identificadores para o seu próprio sistema

Se você vai distribuir nomes que as pessoas guardam (em documentos, favoritos, planilhas, outros sistemas), estas regras evitam arrependimentos:

  1. Faça o nome opaco. Não ponha nele o título, o dono, a pasta, a data ou o status. Tudo que for significativo um dia estará errado (o título muda, o dono sai), e o identificador não pode mudar.
  2. Nunca reutilize um identificador, mesmo depois de apagar o que ele nomeava. O link antigo de alguém não pode abrir o documento de um estranho.
  3. Separe o nome do local com um mapeamento que você controla, e faça o mapeamento atualizável pelo dono, com uma trilha de auditoria.
  4. Decida as regras de maiúsculas e de caracteres desde o início (insensível a maiúsculas, um alfabeto sem caracteres parecidos como 0 e O) e normalize na borda.
  5. Acrescente um caractere verificador se humanos vão digitá-lo.
  6. Mantenha "removido" como uma resposta real. Quando a coisa é apagada, guarde o nome e responda com uma página tombstone ("isto foi removido em …, aqui está o motivo") e um 410, não um 404. Sistemas no estilo DOI normalmente mantêm o registro e os metadados mesmo quando o conteúdo se foi.
  7. Decida o que significa uma nova versão. Ou o nome sempre aponta para a versão mais recente, ou cada versão ganha seu próprio nome mais um nome que acompanha a mais recente. Alguns repositórios, como o Zenodo, dão a cada versão o seu próprio DOI e mais um DOI que sempre aponta para a mais nova, de modo que tanto citar uma versão precisa quanto citar "o software" funcionam.
  8. Escreva a política: quem pode mudar um mapeamento, com que rapidez e o que acontece com os identificadores se a sua organização deixar de existir.

O encurtador em Projetando um encurtador de URL é o primo leve disto: um código curto mapeado para uma URL longa. A diferença é a promessa: um encurtador tem permissão para apodrecer; um serviço de identificadores persistentes existe para cumprir essa promessa.

10. Erros comuns

11. Perguntas que os entrevistadores gostam de acrescentar

"Por que não usar simplesmente URLs?"

Uma URL funde nome e local, então qualquer mudança quebra todas as citações. Um identificador persistente põe uma tabela entre eles, de modo que uma mudança é uma atualização. O custo é que alguém precisa manter a tabela atualizada, o que é um compromisso organizacional, não código.

"Por que o resolvedor responde com um 302 e não com um 301?"

Porque o mapeamento foi feito para mudar. Navegadores e proxies podem fazer cache de um 301 indefinidamente (no meu teste, uma visita depois da mudança ainda foi ao local antigo e nunca chegou ao resolvedor), então os leitores ficariam presos no local antigo. Um redirecionamento temporário, com um Cache-Control deliberado, deixa as atualizações chegarem às pessoas.

"Como você detectaria um erro de digitação em um identificador?"

Acrescente um caractere verificador se as pessoas o digitam (ISBN, ORCID). Para um identificador sem um, como um DOI, você só pode verificar o formato e depois resolvê-lo. Medi verificações de formato aceitando toda mudança de um único dígito.

"O que acontece com um DOI quando a editora desaparece?"

Nada acontece sozinho: o nome ainda resolve para o último local conhecido, que pode estar morto. Na prática, as agências exigem que os registrantes mantenham os registros atualizados e podem apontar o nome para uma página tombstone; os metadados podem continuar existindo. É por isso que os arquivos e os arranjos de sucessão das editoras importam.

"Como você armazenaria DOIs em um banco de dados?"

Guarde a chave normalizada, em minúsculas, em uma coluna única (e a grafia original ao lado, para exibição), indexe-a e ponha ao lado dela a agência de registro e o último destino verificado. Compare chaves, nunca strings puras.

"Onde você usaria negociação de conteúdo?"

Sempre que um nome tem várias representações e quem pede é uma máquina, não uma pessoa: exportações de citações, API versus HTML para o mesmo recurso, variantes de idioma. Lembre-se do Vary para os caches.

12. Coisas a mencionar em uma entrevista

Resumo rápido

Apêndice: o código dos experimentos

Biblioteca padrão do Python 3 mais o Playwright para o teste de redirecionamento (pip install playwright, playwright install chromium). Tempos e contagens vêm da minha execução; os testes aleatórios usam sementes fixas.

ids.py: dígitos verificadores, detecção de erros e normalização de DOI:

import random, re
from urllib.parse import unquote

# --- check digits ---
def isbn13_ok(s):
    d=[int(c) for c in s if c.isdigit()]
    return len(d)==13 and sum(x*(1 if i%2==0 else 3) for i,x in enumerate(d))%10==0
def isbn10_ok(s):
    ch=[c for c in s.upper() if c.isdigit() or c=="X"]
    if len(ch)!=10: return False
    v=[10 if c=="X" else int(c) for c in ch]
    return sum((10-i)*x for i,x in enumerate(v))%11==0
def orcid_check_digit(first15):
    total=0
    for ch in first15: total=(total+int(ch))*2
    r=(12-total%11)%11
    return "X" if r==10 else str(r)
def orcid_ok(s):
    s=s.replace("-","")
    return len(s)==16 and s[:15].isdigit() and orcid_check_digit(s[:15])==s[15]

print("known good:", isbn13_ok("978-0-306-40615-7"), isbn10_ok("0-306-40615-2"), orcid_ok("0000-0002-1825-0097"), "| known bad:", isbn13_ok("978-0-306-40615-8"), isbn10_ok("0-306-40615-3"), orcid_ok("0000-0002-1825-0098"))

# --- how often does each scheme notice a typo? ---
rnd=random.Random(1)
def rand_isbn13():
    d=[9,7,8]+[rnd.randrange(10) for _ in range(9)]
    c=(10-sum(x*(1 if i%2==0 else 3) for i,x in enumerate(d))%10)%10
    return "".join(map(str,d+[c]))
def rand_orcid():
    f="".join(str(rnd.randrange(10)) for _ in range(15)); return f+orcid_check_digit(f)
def mutate_sub(s,digits_only=True):
    i=rnd.randrange(len(s)); alt=[c for c in "0123456789" if c!=s[i]]; return s[:i]+rnd.choice(alt)+s[i+1:]
def mutate_swap(s):
    while True:
        i=rnd.randrange(len(s)-1)
        if s[i]!=s[i+1]: return s[:i]+s[i+1]+s[i]+s[i+2:]
N=100_000
for name,gen,ok in (("ISBN-13",rand_isbn13,isbn13_ok),("ORCID iD",rand_orcid,orcid_ok)):
    ids=[gen() for _ in range(N)]
    sub=sum(not ok(mutate_sub(x)) for x in ids)/N; sw=sum(not ok(mutate_swap(x)) for x in ids)/N
    print(f"{name}: one wrong digit noticed {100*sub:.2f}% | two adjacent digits swapped noticed {100*sw:.2f}%  ({N} random ids each)")

# --- DOIs have no check digit: only the syntax can be checked ---
DOI=re.compile(r"^10\.\d{4,9}/\S+$")
def normalise_doi(s):
    s=s.strip()
    s=re.sub(r"^(?:https?://(?:dx\.)?doi\.org/|doi:\s*)","",s,flags=re.I)
    s=unquote(s)
    return s.lower() if DOI.match(s) else None
dois=["10.1145/362686.362692","10.1145/509907.509965","10.1016/S0169-7552(98)00110-X","10.1371/journal.pone.0115253","10.1002/(SICI)1097-4571(199806)49:8<693::AID-ASI4>3.0.CO;2-O"]
d0="10.1145/362686.362692"
pos=[i for i,c in enumerate(d0) if i>=3 and c.isdigit()]      # digits after "10." : registrant and suffix
acc=0
for _ in range(20_000):
    i=rnd.choice(pos); alt=rnd.choice([c for c in "0123456789" if c!=d0[i]]); acc+=bool(DOI.match(d0[:i]+alt+d0[i+1:]))
print(f"syntax accepts {acc} of 20000 single-digit changes to {d0} (it cannot tell a typo from another DOI)")
for t in ["https://doi.org/10.1145/362686.362692","HTTP://DX.DOI.ORG/10.1145/362686.362692","doi: 10.1145/362686.362692","10.1016/S0169-7552(98)00110-X","https://doi.org/10.1016/s0169-7552%2898%2900110-x","not a doi","10.12/short"]:
    print(f"  {t!r:60} -> {normalise_doi(t)!r}")

redir.py: quais redirecionamentos um navegador real guarda em cache depois que o destino muda:

import http.server, socketserver, threading
from playwright.sync_api import sync_playwright
TARGET={"url":"/a"}; HITS=[]; CFG={"code":301,"cc":None}
class H(http.server.BaseHTTPRequestHandler):
    def log_message(self,*a): pass
    def do_GET(self):
        HITS.append(self.path)
        if self.path.startswith("/r/"):
            self.send_response(CFG["code"]); self.send_header("Location",TARGET["url"])
            if CFG["cc"]: self.send_header("Cache-Control",CFG["cc"])
            self.send_header("Content-Length","0"); self.end_headers(); return
        b=f"landed on {self.path}".encode(); self.send_response(200); self.send_header("Content-Length",str(len(b))); self.end_headers(); self.wfile.write(b)
class S(socketserver.ThreadingMixIn,http.server.HTTPServer): daemon_threads=True
srv=S(("127.0.0.1",8771),H); threading.Thread(target=srv.serve_forever,daemon=True).start()
print("status | Cache-Control | 2nd visit after the target moved | did the resolver see the 2nd visit?")
with sync_playwright() as p:
    br=p.chromium.launch()
    for code,cc in [(301,None),(308,None),(302,None),(307,None),(301,"no-store"),(301,"max-age=60"),(302,"max-age=60")]:
        ctx=br.new_context(); pg=ctx.new_page(); CFG.update(code=code,cc=cc)
        key=f"/r/{code}{cc or ''}".replace("=","").replace("-","")
        TARGET["url"]="/a"; HITS.clear(); pg.goto("http://127.0.0.1:8771"+key); first=pg.url.rsplit("/",1)[1]
        TARGET["url"]="/b"; HITS.clear(); pg.goto("http://127.0.0.1:8771"+key); second=pg.url.rsplit("/",1)[1]; seen=any(h==key for h in HITS)
        print(f"{code}    | {cc or '(none)':11} | went to /{second} (should be /b) | {'yes' if seen else 'NO, answered from the browser cache'}")
        ctx.close()
    br.close()

Fontes

  1. Martin Klein, Herbert Van de Sompel, Robert Sanderson e outros, Scholarly Context Not Found: One in Five Articles Suffers from Reference Rot, PLOS ONE, 2014 (DOI 10.1371/journal.pone.0115253). Os números citados vêm do seu resumo.
  2. Tim Berners-Lee, Cool URIs don't change, W3C, 1998.
  3. IETF, RFC 3650: Handle System Overview, com a RFC 3651 (definição de espaço de nomes e serviço) e a RFC 3652 (protocolo). O sistema DOI é construído sobre o Handle System.
  4. ORCID, Format of the ORCID iD. A estrutura e o caractere verificador ISO 7064 MOD 11-2; o código acima implementa o seu algoritmo.
  5. IETF, RFC 9110: HTTP Semantics (códigos de status de redirecionamento) e RFC 9111: HTTP Caching.
  6. Crossref, Content negotiation (valores de Accept suportados) e DOI content negotiation.
  7. Crossref, DOI display guidelines (mostrar DOIs como links completos https://doi.org/…).

Pratique este tema: Networking & APIs

Mais guias