Namespace

Na computação, um namespace é um conjunto de sinais (nomes) que são usados para identificar e referir-se a objetos de vários tipos. Um namespace garante que todo um determinado conjunto de objetos tenha nomes exclusivos para que possam ser facilmente identificados.

Os namespaces são normalmente estruturados como hierarquias para permitir a reutilização de nomes em diferentes contextos. Como analogia, considere um sistema de nomeação de pessoas onde cada pessoa tem um nome próprio, assim como um sobrenome compartilhado com seus parentes. Se os primeiros nomes dos membros da família forem únicos apenas dentro de cada família, cada pessoa poderá ser identificada exclusivamente pela combinação do primeiro nome e do sobrenome; existe apenas uma Jane Doe, embora possa haver muitas Janes. Dentro do namespace da família Doe, apenas "Jane" é suficiente para designar inequivocamente esta pessoa, enquanto dentro do "global" namespace de todas as pessoas, o nome completo deve ser usado.

Exemplos proeminentes de namespaces incluem sistemas de arquivos, que atribuem nomes a arquivos. Algumas linguagens de programação organizam suas variáveis e sub-rotinas em namespaces. Redes de computadores e sistemas distribuídos atribuem nomes a recursos, como computadores, impressoras, sites e arquivos remotos. Os sistemas operacionais podem particionar recursos do kernel por namespaces isolados para oferecer suporte a contêineres de virtualização.

Da mesma forma, sistemas de arquivos hierárquicos organizam arquivos em diretórios. Cada diretório é um namespace separado, de modo que as "letras" e "faturas" ambos podem conter um arquivo "to_jane".

Na programação de computadores, os namespaces são normalmente empregados com a finalidade de agrupar símbolos e identificadores em torno de uma funcionalidade específica e evitar colisões de nomes entre vários identificadores que compartilham o mesmo nome.

Na rede, o Domain Name System organiza sites (e outros recursos) em namespaces hierárquicos.

Conflitos de nomes

Os nomes dos elementos são definidos pelo desenvolvedor. Isso geralmente resulta em um conflito ao tentar misturar documentos XML de diferentes aplicativos XML.

Este XML contém informações da tabela HTML:

    
Maçãs
Laranjas

Este XML contém informações sobre uma mesa (ou seja, uma peça de mobiliário):

 Maquiagem Café Quadro 80 120

Se esses fragmentos XML fossem adicionados, haveria um conflito de nomes. Ambos contêm um elemento <table>...</table>, mas os elementos têm conteúdo e significado diferentes.

Um analisador XML não saberá como lidar com essas diferenças.

Solução via prefixo

Conflitos de nomes em XML podem ser facilmente evitados usando um prefixo de nome.

O XML a seguir distingue entre as informações sobre a tabela HTML e os móveis prefixando "h" e "f" no início dos elementos.

  Maçãs Laranjas  Maquiagem Café Quadro 80 120

Sistema de nomenclatura

Um nome em um namespace consiste em um nome de namespace e um nome local. O nome do namespace geralmente é aplicado como um prefixo ao nome local.

Na forma de Backus-Naur aumentada:

nome =  separador 

Quando nomes locais são usados sozinhos, a resolução de nomes é usada para decidir qual (se houver) nome específico é aludido por algum nome local específico.

Exemplos

Delegação

A delegação de responsabilidades entre as partes é importante em aplicativos do mundo real, como a estrutura da World Wide Web. Os namespaces permitem a delegação da atribuição de identificadores a várias organizações emissoras de nomes, mantendo a exclusividade global. Uma autoridade de registro central registra os nomes de namespace atribuídos alocados. Cada nome de namespace é alocado para uma organização que é subsequentemente responsável pela atribuição de nomes em seu namespace alocado. Essa organização pode ser uma organização emissora de nomes que atribui os próprios nomes ou outra autoridade de registro que delega partes de seu namespace a diferentes organizações.

Hierarquia

Um esquema de nomenclatura que permite a subdelegação de namespaces para terceiros é um namespace hierárquico.

Uma hierarquia é recursiva se a sintaxe dos nomes de namespace for a mesma para cada subdelegação. Um exemplo de hierarquia recursiva é o sistema de nomes de domínio.

Um exemplo de hierarquia não recursiva é o nome de recurso uniforme que representa um número IANA (Internet Assigned Numbers Authority).

Namespace versus escopo

Um nome de namespace pode fornecer contexto (escopo na ciência da computação) para um nome, e os termos às vezes são usados de forma intercambiável. No entanto, o contexto de um nome também pode ser fornecido por outros fatores, como o local onde ocorre ou a sintaxe do nome.

Em linguagens de programação

Para muitas linguagens de programação, namespace é um contexto para seus identificadores. Em um sistema operacional, um exemplo de namespace é um diretório. Cada nome em um diretório identifica exclusivamente um arquivo ou subdiretório.

Como regra, os nomes em um namespace não podem ter mais de um significado; ou seja, significados diferentes não podem compartilhar o mesmo nome no mesmo namespace. Um namespace também é chamado de contexto, porque o mesmo nome em diferentes namespaces pode ter diferentes significados, cada um apropriado para seu namespace.

A seguir estão outras características dos namespaces:

• Nomes no namespace podem representar objetos, bem como conceitos, ser o namespace uma linguagem natural ou étnica, uma linguagem construída, a terminologia técnica de uma profissão, um dialeto, um socioleto ou uma linguagem artificial (por exemplo, uma linguagem de programação).
• Na linguagem de programação Java, identificadores que aparecem em namespaces têm um nome curto (local) e um nome único longo "qualificado" para uso fora do namespace.
• Alguns compiladores (para idiomas como C++) combinam namespaces e nomes para uso interno no compilador em um processo chamado nome mangling.

Além de seu uso técnico de linguagem abstrata conforme descrito acima, alguns idiomas têm uma palavra-chave específica usada para controle explícito de espaço de nomes, entre outros usos. Abaixo está um exemplo de um namespace em C++:

#include # // É assim que se traz um nome para o escopo atual. Neste caso, é// levando-os ao alcance global.usando O quê?:Couto;usando O quê?:);namespace Caixa 1 ( - Não. Box_side = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = 4;?namespace caixa2 ( - Não. Box_side = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = 12;?- Não. principal() ( - Não. Box_side = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = 42; Couto < < Caixa 1:Box_side < < ); // Saídas 4. Couto < < caixa2:Box_side < < ); // Saídas 12. Couto < < Box_side < < ); // Saídas 42.?

Considerações de ciência da computação

Um namespace em ciência da computação (às vezes também chamado de escopo de nome) é um contêiner ou ambiente abstrato criado para manter um agrupamento lógico de identificadores ou símbolos exclusivos (ou seja, nomes). Um identificador definido em um namespace é associado apenas a esse namespace. O mesmo identificador pode ser definido independentemente em vários namespaces. Ou seja, um identificador definido em um namespace pode ou não ter o mesmo significado que o mesmo identificador definido em outro namespace. As linguagens que suportam namespaces especificam as regras que determinam a qual namespace um identificador (não sua definição) pertence.

Esse conceito pode ser ilustrado com uma analogia. Imagine que duas empresas, X e Y, cada uma atribua números de identificação a seus funcionários. X não deve ter dois funcionários com o mesmo número de identificação, e o mesmo para Y; mas não é um problema para o mesmo número de identificação ser usado em ambas as empresas. Por exemplo, se Bill trabalha para a empresa X e Jane trabalha para a empresa Y, então não é um problema para cada um deles ser o funcionário nº 123. Nessa analogia, o número de ID é o identificador e a empresa serve como namespace. Não causa problemas para o mesmo identificador identificar uma pessoa diferente em cada namespace.

Em grandes programas de computador ou documentos é comum ter centenas ou milhares de identificadores. Os namespaces (ou uma técnica semelhante, consulte Emulando namespaces) fornecem um mecanismo para ocultar identificadores locais. Eles fornecem um meio de agrupar identificadores logicamente relacionados em espaços de nomes correspondentes, tornando o sistema mais modular.

Dispositivos de armazenamento de dados e muitas linguagens de programação modernas suportam namespaces. Os dispositivos de armazenamento usam diretórios (ou pastas) como namespaces. Isso permite que dois arquivos com o mesmo nome sejam armazenados no dispositivo, desde que sejam armazenados em diretórios diferentes. Em algumas linguagens de programação (por exemplo, C++, Python), os identificadores que nomeiam namespaces são associados a um namespace envolvente. Assim, nessas linguagens os namespaces podem se aninhar, formando uma árvore de namespaces. Na raiz desta árvore está o namespace global sem nome.

Uso em idiomas comuns

C

É possível usar estruturas anônimas como namespaces em C desde C99.

// helper.cestática - Não. Anúncio(- Não. um, - Não. b)) ( retorno um + b);?Não. Estranho ( duplo Pai!; - Não. (*Adicionar) (- Não., - Não.);? Ajudante = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = ( 3.14, Anúncio }// helper.hNão. Estranho ( duplo Pai!; - Não. (*Adicionar) (- Não., - Não.);? Ajudante;// main.c#include # #include # "helper.h"- Não. principal( Impressão("3 + 2 = %dNão.", Ajudante.Adicionar(3, 2)); Impressão("pi é %fNão.", Ajudante.Pai!);?

C++

Em C++, um namespace é definido com um bloco de namespace.

namespace Abdc ( - Não. bar;?

Dentro deste bloco, os identificadores podem ser usados exatamente como são declarados. Fora desse bloco, o especificador de namespace deve ser prefixado. Por exemplo, fora de namespace abc, bar deve ser escrito abc::bar para ser acessado. C++ inclui outra construção que torna essa verbosidade desnecessária. Ao adicionar a linha

usando namespace Abdc;

para um pedaço de código, o prefixo abc:: não é mais necessário.

Os identificadores que não são declarados explicitamente em um namespace são considerados no namespace global.

- Não. Foo;

Esses identificadores podem ser usados exatamente como são declarados ou, como o namespace global não tem nome, o especificador de namespace :: pode ser prefixado. Por exemplo, foo também pode ser escrito ::foo.

A resolução do namespace em C++ é hierárquica. Isso significa que dentro do namespace hipotético food::soup, o identificador chicken refere-se a food::soup::chicken. Se food::soup::chicken não existir, ele se refere a food::chicken. Se nem food::soup::chicken nem food::chicken existirem, chicken se refere a ::chicken, um identificador no namespace global.

Os namespaces em C++ são usados com mais frequência para evitar colisões de nomenclatura. Embora os namespaces sejam amplamente usados no código C++ recente, a maioria dos códigos mais antigos não usa esse recurso porque ele não existia nas versões anteriores da linguagem. Por exemplo, toda a biblioteca padrão C++ é definida em namespace std, mas antes da padronização muitos componentes estavam originalmente no namespace global. Um programador pode inserir a diretiva using para ignorar os requisitos de resolução de namespace e obter compatibilidade com versões anteriores de códigos mais antigos que esperam que todos os identificadores estejam no namespace global. No entanto, o uso da diretiva using por motivos diferentes da compatibilidade com versões anteriores (por exemplo, conveniência) é considerado contra as boas práticas de código.

Java

Em Java, a ideia de um namespace é incorporada em pacotes Java. Todo código pertence a um pacote, embora esse pacote não precise ser nomeado explicitamente. O código de outros pacotes é acessado prefixando o nome do pacote antes do identificador apropriado, por exemplo class String em pacote java.lang pode ser referido como java.lang.String (isso é conhecido como o nome de classe totalmente qualificado). Como C++, Java oferece uma construção que torna desnecessário digitar o nome do pacote (import). No entanto, certos recursos (como reflexão) exigem que o programador use o nome totalmente qualificado.

Ao contrário do C++, os namespaces em Java não são hierárquicos no que diz respeito à sintaxe da linguagem. No entanto, os pacotes são nomeados de maneira hierárquica. Por exemplo, todos os pacotes que começam com java fazem parte da plataforma Java — o pacote java.lang contém as classes principais da linguagem e java.lang. reflect contém classes principais relacionadas especificamente à reflexão.

Em Java (e Ada, C# e outros), namespaces/pacotes expressam categorias semânticas de código. Por exemplo, em C#, namespace System contém código fornecido pelo sistema (the.NET Framework). A especificidade dessas categorias e a profundidade das hierarquias variam de idioma para idioma.

Os escopos de função e classe podem ser vistos como namespaces implícitos que estão intrinsecamente ligados à visibilidade, acessibilidade e tempo de vida do objeto.

C#

Os namespaces são muito usados na linguagem C#. Todas as classes do.NET Framework são organizadas em namespaces, para serem usadas com mais clareza e evitar o caos. Além disso, os namespaces personalizados são amplamente usados pelos programadores, tanto para organizar seu trabalho quanto para evitar colisões de nomenclatura. Ao fazer referência a uma classe, deve-se especificar seu nome totalmente qualificado, que significa namespace seguido pelo nome da classe,

Sistema.Console.Linha de produção("Olá Mundo!");- Não. Eu... = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = Sistema.Converter.ToInt32("123");

ou adicione uma instrução using. Isso elimina a necessidade de mencionar o nome completo de todas as classes nesse namespace.

usando Sistema;Console.Linha de produção("Olá Mundo!");- Não. Eu... = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = Converter.ToInt32("123");

Nos exemplos acima, System é um namespace e Console e Convert são classes definidas em System.

Python

Em Python, os namespaces são definidos pelos módulos individuais e, como os módulos podem estar contidos em pacotes hierárquicos, os namespaces também são hierárquicos. Em geral, quando um módulo é importado, os nomes definidos no módulo são definidos por meio do namespace desse módulo e são acessados a partir dos módulos de chamada usando o nome totalmente qualificado.

# assume modulea define duas funções: func1() e func2() e uma classe: Class1importação MóduloMódulo.Funk1()Módulo.Funk2()um = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = Módulo.Classe 1()

A instrução from... import... pode ser usada para inserir os nomes relevantes diretamente no namespace do módulo de chamada, e esses nomes podem ser acessados do módulo de chamada sem o nome qualificado:

# assume Modulea define duas funções: func1() e func2() e uma classe: Class1a partir de Módulo importação Funk1Funk1()Funk2() # isto falhará como um nome indefinido, assim como o nome completo Modulea.func2()um = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = Classe 1() Isso falhará como um nome indefinido, assim como o nome completo Modulea. Class1()

Como isso importa nomes diretamente (sem qualificação), ele pode sobrescrever nomes existentes sem avisos.

Uma forma especial da instrução é from... import * que importa todos os nomes definidos no pacote nomeado diretamente no namespace do módulo de chamada. O uso dessa forma de importação, embora suportada na linguagem, geralmente é desencorajado, pois polui o namespace do módulo de chamada e fará com que os nomes já definidos sejam sobrescritos no caso de conflito de nomes.

Python também suporta import x as y como uma forma de fornecer um alias ou nome alternativo para uso pelo módulo de chamada:

importação - Sim. como num = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = n.uma variedade(1000)

Espaço de nomes XML

Em XML, a especificação de namespace XML permite que os nomes de elementos e atributos em um documento XML sejam exclusivos, semelhante à função dos namespaces em linguagens de programação. Usando namespaces XML, os documentos XML podem conter nomes de elementos ou atributos de mais de um vocabulário XML.

PHP

Os namespaces foram introduzidos no PHP a partir da versão 5.3 em diante. A colisão de nomes de classes, funções e variáveis pode ser evitada. Em PHP, um namespace é definido com um bloco de namespace.

# Arquivo phpstar/foobar.phpnamespace phpstar;classe FooBar( público função Foo(): vazio ( Echo ' Olá, mundo, da função foo '; ? público função bar(): vazio ( Echo ' Olá, mundo, da barra de função '; ??

Podemos fazer referência a um namespace PHP das seguintes maneiras diferentes:

# Índice de arquivo.php# Incluir o arquivoincluir "Fpstar/foobar.php";# Opção 1: prefixe diretamente o nome da classe com o namespaceO que foi? = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = novo novo  phpstarFooBar();# Opção 2: importe o namespaceuso phpstarFooBar;O que foi? = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = novo novo FooBar();# Option 2a: import & alias the namespaceuso phpstarFooBar como FB;O que foi? = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = novo novo FB();# Acesse as propriedades e métodos com a maneira regularO que foi?- Sim.Foo();O que foi?- Sim.bar();

Emulando namespaces

Em linguagens de programação sem suporte de linguagem para namespaces, os namespaces podem ser emulados até certo ponto usando uma convenção de nomenclatura de identificador. Por exemplo, bibliotecas C como libpng geralmente usam um prefixo fixo para todas as funções e variáveis que fazem parte de sua interface exposta. Libpng expõe identificadores como:

png_create_write_struct
png_get_signature
Png_read_row
png_set_invalid

Esta convenção de nomenclatura fornece uma garantia razoável de que os identificadores são exclusivos e, portanto, podem ser usados em programas maiores sem colisões de nomenclatura. Da mesma forma, muitos pacotes originalmente escritos em Fortran (por exemplo, BLAS, LAPACK) reservam as primeiras letras do nome de uma função para indicar a qual grupo ela pertence.

Esta técnica tem várias desvantagens:

• Não dimensiona bem para namespaces aninhados; identificadores se tornam excessivamente longos, uma vez que todos os usos dos identificadores devem ser totalmente classificados pelo namespace.
• Indivíduos ou organizações podem usar convenções de nomeação inconsistentes, potencialmente introduzindo obfusca indesejada.
• Operações compostas ou "baseadas em consultas" em grupos de identificadores, com base nos namespaces em que eles são declarados, são tornadas indevidas ou incomparáveis.
• Em idiomas com comprimento de identificador restrito, o uso de prefixos limita o número de caracteres que podem ser usados para identificar o que a função faz. Este é um problema particular para pacotes originalmente escritos em FORTRAN 77, que ofereceu apenas 6 caracteres por identificador. Por exemplo, o nome da função BLAS DGEMM função indica que ele opera em números de dupla precisão ("D") e matrizes gerais ("GE"), e apenas os dois últimos caracteres mostram o que realmente faz: multiplicação matriz (o "MM").

Existem várias vantagens:

• Nenhuma ferramenta de software especial é necessária para localizar nomes em arquivos de código-fonte. Um programa simples como o Griep é suficiente.
• Não há conflitos de nome no namespace.
• Não há necessidade de nome-mangling, e, portanto, não há problemas potenciais de incompatibilidade.