Por que os programas não são escritos no Assembly com mais frequência? [fechadas]

Parece ser uma opinião comum que a programação em assembly leva mais tempo e é mais difícil de programar do que em uma linguagem de nível superior, como C. Portanto, parece recomendável ou presumido que é melhor escrever em uma linguagem de nível superior por esses motivos. e por uma melhor portabilidade.

Recentemente, escrevi no assembly x86 e me ocorreu que talvez esses motivos não sejam realmente verdadeiros, exceto talvez a portabilidade. Talvez seja mais uma questão de familiaridade e saber escrever bem uma montagem. Notei também que a programação em assembly é bem diferente da programação em uma HLL. Talvez um programador de montagem bom e experiente possa escrever programas com a mesma facilidade e rapidez que um programador C experiente escrevendo em C.

Talvez seja porque a programação de montagem seja bem diferente das HLLs e, portanto, exija pensamentos, métodos e maneiras diferentes, o que faz parecer muito estranho programar para pessoas desconhecidas e, por isso, dá o nome errado ao escrever programas.

Se a portabilidade não é um problema, então realmente, o que C teria sobre um bom montador como o NASM?

Edit: Apenas para apontar. Quando você está escrevendo em montagem, não precisa escrever apenas nos códigos de instruções. Você pode usar macros e procedimentos e suas próprias convenções para fazer várias abstrações para tornar os programas mais modulares, mais fáceis de manter e mais fáceis de ler. É aqui que entra o conhecimento de como escrever uma boa montagem.

O ASM tem pouca legibilidade e não é realmente sustentável em comparação com idiomas de nível superior.

Além disso, há muito menos desenvolvedores ASM do que em outros idiomas mais populares, como C.

Além disso, se você usar um idioma de nível superior e novas instruções ASM estiverem disponíveis (SSE, por exemplo), você só precisará atualizar seu compilador e seu código antigo poderá facilmente usar as novas instruções.

E se a próxima CPU tiver o dobro de registros?

O inverso dessa pergunta seria: Que funcionalidade os compiladores fornecem?

Duvido que você possa / queira / deve otimizar seu ASM melhor do que gcc -O3pode.

Olá, eu sou um compilador.

Acabei de digitalizar milhares de linhas de código enquanto você estava lendo esta frase. Naveguei por milhões de possibilidades de otimizar uma única linha sua usando centenas de técnicas diferentes de otimização, com base em uma vasta quantidade de pesquisas acadêmicas nas quais você passaria anos. Não sentirei vergonha, nem mesmo uma ligeira pontada, quando converter um loop de três linhas em milhares de instruções apenas para torná-lo mais rápido. Não tenho vergonha de fazer grandes esforços de otimização ou de fazer os truques mais sujos. E se você não quiser, talvez por um dia ou dois, eu me comportarei e farei da maneira que você quiser. Posso transformar os métodos que estou usando quando quiser, sem alterar uma única linha do seu código. Eu posso até mostrar como seu código ficaria em assembly, em diferentes arquiteturas de processador e diferentes sistemas operacionais e em diferentes convenções de montagem, se desejar. Sim, tudo em segundos. Porque, você sabe, eu posso; e você sabe, você não pode.

PS Oh, a propósito, você não estava usando metade do código que escreveu. Fiz um favor e joguei fora.

Eu escrevi shedloads de assembler para os chips 6502, Z80, 6809 e 8086. Parei de fazê-lo assim que os compiladores C se tornaram disponíveis para as plataformas que eu estava abordando e imediatamente fiquei pelo menos 10x mais produtivo. A maioria dos bons programadores usa as ferramentas que utiliza por razões racionais.

Adoro programar em linguagem assembly, mas é preciso mais código para fazer a mesma coisa que em um idioma de alto nível, e há uma correlação direta entre linhas de código e bugs. (Isso foi explicado décadas atrás no The Mythical Man-Month .)

É possível pensar em C como 'montagem de alto nível', mas dê alguns passos acima e você estará em um mundo diferente. Em C #, você não pensa duas vezes em escrever isso:

foreach (string s in listOfStrings) { /* do stuff */ }

Seriam dezenas, talvez centenas de linhas de código em assembly, cada programador que o implementasse adotaria uma abordagem diferente e a próxima pessoa que chegasse teria que descobrir isso. Portanto, se você acredita (como muitos acreditam) que os programas são escritos principalmente para outras pessoas lerem, a montagem é menos legível do que a HLL típica.

Edit: eu acumulei uma biblioteca pessoal de código usada para tarefas comuns e macros para implementar estruturas de controle do tipo C. Mas eu bati na parede nos anos 90, quando as GUIs se tornaram a norma. Muito tempo estava sendo gasto em coisas rotineiras.

A última tarefa que tive onde o ASM era essencial foi, há alguns anos, escrever código para combater malware. Sem interface do usuário, por isso foram todas as partes divertidas sem o inchaço.

Além das respostas de legibilidade, capacidade de manutenção, código mais curto e, portanto, menos bugs, além de ser muito mais fácil, adicionarei um motivo adicional:

velocidade do programa.

Sim, na montagem, você pode ajustar manualmente seu código para fazer uso de todos os ciclos anteriores e torná-lo o mais rápido possível fisicamente. No entanto, quem tem tempo? Se você escrever um programa C não totalmente estúpido, o compilador fará um ótimo trabalho de otimização para você. Provavelmente, faça pelo menos 95% das otimizações que você faria manualmente, sem precisar se preocupar em acompanhar nenhuma delas. Definitivamente, existe um tipo de regra 90/10 aqui, onde os últimos 5% das otimizações acabarão ocupando 95% do seu tempo. Então, por que se preocupar?

Se um programa de produção médio tiver 100 mil linhas de código e cada linha tiver entre 8 e 12 instruções para montagem, isso representará 1 milhão de instruções para montagem.

Mesmo se você pudesse escrever tudo isso à mão a uma velocidade decente (lembre-se, é 8 vezes mais código do que precisa escrever), o que acontece se você quiser alterar algumas das funcionalidades? Compreender algo que você escreveu há algumas semanas atrás com essas 1 milhão de instruções é um pesadelo! Não há módulos, classes, design orientado a objetos, estruturas, nada. E a quantidade de código semelhante que você precisa escrever para as coisas mais simples é assustadora, na melhor das hipóteses.

Além disso, você não pode otimizar seu código quase tão bem quanto uma linguagem de alto nível. Onde C, por exemplo, executa um número insano de otimizações porque você descreve sua intenção, não apenas seu código, no assembler você escreve apenas código, o assembler não pode realmente executar nenhuma otimização digna de nota em seu código. O que você escreve é ​​o que obtém e, confie em mim, não pode otimizar com segurança 1 milhão de instruções que você corrige e corrige ao escrevê-las.

Bem, eu tenho escrito muita montagem "nos velhos tempos" e posso garantir que sou muito mais produtivo quando escrevo programas em uma linguagem de alto nível.

Um nível razoável de competência de montador é uma habilidade útil, especialmente se você trabalha em qualquer tipo de nível de sistema ou programação incorporada, não tanto porque você precisa escrever tanto montador, mas porque às vezes é importante entender o que a caixa realmente está fazendo . Se você não tem um entendimento de baixo nível dos conceitos e problemas do assembler, isso pode ser muito difícil.

No entanto, quanto à realmente escrever muito código no assembler, há várias razões para isso não ser muito feito.

• Simplesmente não há (quase) necessidade. Exceto por algo como a inicialização muito precoce do sistema e talvez alguns fragmentos de assembler ocultos em funções ou macros C, todos os códigos de nível muito baixo que podem ter sido escritos no assembler podem ser escritos em C ou C ++ sem dificuldade.

• O código em linguagens de nível superior (mesmo C e C ++) condensa a funcionalidade em muito menos linhas, e há uma pesquisa considerável mostrando que o número de bugs se correlaciona com o número de linhas do código-fonte. Ou seja, o mesmo problema, resolvido no assembler e C, terá mais erros no assembler simplesmente porque é mais longo. O mesmo argumento motiva a mudança para linguagens de nível superior, como Perl, Python, etc.

• Ao escrever no assembler, você precisa lidar com todos os aspectos do problema, desde o layout detalhado da memória, seleção de instruções, escolhas de algoritmos, gerenciamento de pilha, etc. Linguagens de nível mais alto tiram tudo isso de você, e é por isso que são muito mais densos termos de LOC.

Essencialmente, todos os itens acima estão relacionados ao nível de abstração disponível para você no assembler versus C ou em algum outro idioma. O Assembler obriga você a fazer todas as suas próprias abstrações e mantê-las através de sua própria autodisciplina, onde qualquer linguagem de nível intermediário como C, e especialmente as de nível superior, fornece abstrações prontas para uso, assim como as capacidade de criar novos com relativa facilidade.

Como desenvolvedor que passa a maior parte do tempo no mundo da programação embarcada, eu argumentaria que o assembly está longe de ser uma linguagem obsoleta / morta. Há um certo nível de codificação próximo ao metal (por exemplo, em drivers) que às vezes não pode ser expresso com precisão ou eficiência em um idioma de nível superior. Escrevemos quase todas as nossas rotinas de interface de hardware no assembler.

Dito isto, esse código de montagem é agrupado de forma que possa ser chamado a partir do código C e é tratado como uma biblioteca. Não escrevemos o programa inteiro em montagem por vários motivos. Primeiro e acima de tudo, é portabilidade; nossa base de código é usada em vários produtos que usam arquiteturas diferentes e queremos maximizar a quantidade de código que pode ser compartilhada entre eles. O segundo é a familiaridade do desenvolvedor. Simplificando, as escolas não ensinam montagem como costumavam fazer, e nossos desenvolvedores são muito mais produtivos em C do que em montagem. Além disso, temos uma grande variedade de "extras" (itens como bibliotecas, depuradores, ferramentas de análise estática etc.) disponíveis para o nosso código C que não estão disponíveis para o código da linguagem assembly. Mesmo se quiséssemos escrever um programa de montagem pura, não seria possível, porque várias bibliotecas críticas de hardware estão disponíveis apenas como C libs. Em certo sentido, é um problema de galinha / ovo. As pessoas são afastadas do assembly porque não existem tantas bibliotecas e ferramentas de desenvolvimento / depuração disponíveis, mas as bibliotecas / ferramentas não existem porque poucas pessoas usam o assembly para justificar o esforço para criá-las.

No final, há um tempo e um lugar para praticamente qualquer idioma. As pessoas usam o que estão mais familiarizadas e produtivas. Provavelmente sempre haverá um lugar no repertório de um programador para montagem, mas a maioria dos programadores descobrirá que pode escrever código em uma linguagem de nível superior que é quase tão eficiente em muito menos tempo.

Quando você está escrevendo em montagem, não precisa escrever apenas nos códigos de instruções. Você pode usar macros e procedimentos e suas próprias convenções para fazer várias abstrações para tornar os programas mais modulares, mais fáceis de manter e mais fáceis de ler.

Então, o que você está basicamente dizendo é que, com o uso qualificado de um assembler sofisticado, você pode tornar seu código ASM cada vez mais próximo de C (ou qualquer outra linguagem de baixo nível de sua própria invenção), até que você acabe tão produtivo quanto um programador em C.

Isso responde à sua pergunta? ;-)

Não digo isso à toa: programei usando exatamente esse montador e sistema. Melhor ainda, o assembler poderia direcionar um processador virtual, e um tradutor separado compilou a saída do assembler para uma plataforma de destino. É o que acontece com o FI da LLVM, mas em suas formas iniciais o pré-data em cerca de 10 anos. Portanto, havia portabilidade, além da capacidade de escrever rotinas para um montador de destino específico, quando necessário, para eficiência.

Escrever usando esse assembler era tão produtivo quanto C e, em comparação com o GCC-3 (que já existia na época em que eu estava envolvido), o assembler / tradutor produziu um código que era mais ou menos rápido e geralmente menor. O tamanho era realmente importante, e a empresa tinha poucos programadores e estava disposta a ensinar aos novos contratados um novo idioma antes que eles pudessem fazer algo útil. E nós tínhamos o apoio de que pessoas que não conheciam o montador (por exemplo, clientes) podiam escrever C e compilá-lo para o mesmo processador virtual, usando a mesma convenção de chamada e assim por diante, para que ele tivesse uma interface organizada. Então parecia uma vitória marginal.

Isso ocorreu com vários anos de trabalho na bolsa, desenvolvendo a tecnologia de montagem, bibliotecas e assim por diante. É certo que muito disso foi feito para torná-lo portátil, se ele tivesse como alvo apenas uma arquitetura, o montador que dançava e dançava seria muito mais fácil.

Em resumo: você pode não gostar de C, mas isso não significa que o esforço de usar C seja maior que o esforço de criar algo melhor.

A montagem não é portátil entre diferentes microprocessadores.

A mesma razão pela qual não vamos mais ao banheiro lá fora, ou por que não falamos latim ou aramaico.

A tecnologia aparece e torna as coisas mais fáceis e acessíveis.

EDIT - para deixar de ofender as pessoas, removi certas palavras.

Por quê? Simples.

Compare isto:

        for (var i = 1; i <= 100; i++)
        {
            if (i % 3 == 0)
                Console.Write("Fizz");
            if (i % 5 == 0)
                Console.Write("Buzz");
            if (i % 3 != 0 && i % 5 != 0)
                Console.Write(i);
            Console.WriteLine();
        }

com

.locals init (
    [0] int32 i)
L_0000: ldc.i4.1 
L_0001: stloc.0 
L_0002: br.s L_003b
L_0004: ldloc.0 
L_0005: ldc.i4.3 
L_0006: rem 
L_0007: brtrue.s L_0013
L_0009: ldstr "Fizz"
L_000e: call void [mscorlib]System.Console::Write(string)
L_0013: ldloc.0 
L_0014: ldc.i4.5 
L_0015: rem 
L_0016: brtrue.s L_0022
L_0018: ldstr "Buzz"
L_001d: call void [mscorlib]System.Console::Write(string)
L_0022: ldloc.0 
L_0023: ldc.i4.3 
L_0024: rem 
L_0025: brfalse.s L_0032
L_0027: ldloc.0 
L_0028: ldc.i4.5 
L_0029: rem 
L_002a: brfalse.s L_0032
L_002c: ldloc.0 
L_002d: call void [mscorlib]System.Console::Write(int32)
L_0032: call void [mscorlib]System.Console::WriteLine()
L_0037: ldloc.0 
L_0038: ldc.i4.1 
L_0039: add 
L_003a: stloc.0 
L_003b: ldloc.0 
L_003c: ldc.i4.s 100
L_003e: ble.s L_0004
L_0040: ret 

Eles são idênticos em termos de recursos. O segundo nem é assembler, mas o .NET IL (Linguagem Intermediária, semelhante ao bytecode de Java). A segunda compilação transforma a IL em código nativo (ou seja, quase assembler), tornando-a ainda mais enigmática.

Eu acho que o ASM até x86 (_64) faz sentido nos casos em que você ganha muito utilizando instruções difíceis para um compilador otimizar. O x264, por exemplo, usa muito ASM para sua codificação, e os ganhos de velocidade são enormes.

Tenho certeza de que há muitas razões, mas duas razões rápidas em que consigo pensar são

1. O código de montagem é definitivamente mais difícil de ler (tenho certeza de que é mais demorado escrever também)
2. Quando você tem uma grande equipe de desenvolvedores trabalhando em um produto, é útil ter seu código dividido em blocos lógicos e protegido por interfaces.

Uma das primeiras descobertas (você encontrará no Mythical Man-Month de Brooks , que é da experiência da década de 1960) foi que as pessoas eram mais ou menos tão produtivas em um idioma quanto em outro, em linhas de código depuradas por dia. Obviamente, isso não é universalmente verdade e pode quebrar quando for levado longe demais, mas geralmente era verdade nos idiomas de alto nível da época de Brooks.

Portanto, a maneira mais rápida de obter produtividade seria usar linguagens em que uma linha de código individual fizesse mais e, de fato, isso funcionaria, pelo menos para linguagens de complexidade como FORTRAN e COBOL, ou para dar um exemplo mais moderno C.

Portabilidade é sempre um problema - se não agora, pelo menos eventualmente. A indústria de programação gasta bilhões todos os anos para portar software antigo que, no momento em que foi escrito, "obviamente" não apresentava nenhum problema de portabilidade.

Houve um ciclo vicioso quando o assembly se tornou menos comum: à medida que as linguagens de nível superior amadureciam, os conjuntos de instruções da linguagem assembly eram construídos menos para a conveniência do programador e mais para a conveniência dos compiladores.

Portanto, agora, realisticamente, pode ser muito difícil tomar as decisões corretas sobre, digamos, quais registros você deve usar ou quais instruções são um pouco mais eficientes. Os compiladores podem usar heurísticas para descobrir quais compensações provavelmente terão o melhor retorno. Provavelmente, podemos pensar em problemas menores e encontrar otimizações locais que podem superar nossos compiladores agora bastante sofisticados, mas as probabilidades são de que, em geral, um bom compilador fará um trabalho melhor na primeira tentativa do que provavelmente um bom programador. Eventualmente, como John Henry, podemos vencer a máquina, mas podemos nos queimar seriamente chegando lá.

Nossos problemas também agora são bem diferentes. Em 1986, eu estava tentando descobrir como obter um pouco mais de velocidade de pequenos programas que envolviam colocar algumas centenas de pixels na tela; Eu queria que a animação fosse menos espasmódica. Um argumento justo para a linguagem assembly. Agora, estou tentando descobrir como representar abstrações em torno da linguagem dos contratos e da política de serviço para hipotecas, e prefiro ler algo que se pareça com o idioma que os executivos falam. Diferentemente das macros LISP, as macros Assembly não impõem muita coisa no que diz respeito a regras, portanto, mesmo que você consiga algo razoavelmente próximo a uma DSL em um bom assembler, ele estará sujeito a todos os tipos de peculiaridades que ganharam ' me causa problemas se eu escrevi o mesmo código em Ruby, Boo, Lisp, C # ou até F #.

Se seus problemas são fáceis de expressar em linguagem assembly eficiente, no entanto, você terá mais poder.

O mesmo vale para o que os outros disseram.

Nos bons velhos tempos antes da invenção do C, quando os únicos idiomas de alto nível eram coisas como COBOL e FORTRAN, havia muitas coisas que simplesmente não eram possíveis sem o recurso ao assembler. Era a única maneira de obter toda a flexibilidade, poder acessar todos os dispositivos, etc. Mas então C foi inventado, e quase tudo o que era possível na montagem era possível em C. Escrevi muito pouca montagem desde então.

Dito isto, acho que é um exercício muito útil para novos programadores aprenderem a escrever no assembler. Não porque eles realmente usariam muito, mas porque então você entende o que realmente está acontecendo dentro do computador. Eu já vi muitos erros de programação e códigos ineficientes de programadores que claramente não têm idéia do que realmente está acontecendo com os bits e bytes e registradores.

Estou programando em montagem agora há cerca de um mês. Costumo escrever um trecho de código em C e depois compilá-lo na montagem para me ajudar. Talvez eu não esteja utilizando todo o poder de otimização do compilador C, mas parece que minha fonte C asm está incluindo operações desnecessárias. Então, estou começando a ver que a conversa de um bom compilador C que supera um bom codificador de montagem nem sempre é verdadeira.

Enfim, meus programas de montagem são tão rápidos. E quanto mais eu uso assembly, menos tempo leva para escrever meu código, porque realmente não é tão difícil. Também o comentário sobre montagem com pouca legibilidade não é verdadeiro. Se você rotular seus programas corretamente e fazer comentários quando houver necessidade de elaboração adicional, tudo estará pronto. De fato, de certa forma, a montagem é mais clara para o programador, porque eles estão vendo o que está acontecendo no nível do processador. Não conheço outros programadores, mas para mim gosto de saber o que está acontecendo, em vez de as coisas estarem em uma espécie de caixa preta.

Com isso dito, a vantagem real dos compiladores é que um compilador pode entender padrões e relacionamentos e depois codificá-los automaticamente nos locais apropriados na fonte. Um exemplo popular são as funções virtuais em C ++, que exigem que o compilador mapeie de maneira ideal os ponteiros de função. No entanto, um compilador está limitado a fazer o que o fabricante do compilador permite que ele faça. Isso leva os programadores às vezes a recorrer a fazer coisas bizarras com seu código, adicionando tempo de codificação, quando eles poderiam ter sido feitos trivialmente com assembly.

Pessoalmente, acho que o mercado suporta fortemente idiomas de alto nível. Se a linguagem assembly fosse a única linguagem existente hoje, seriam cerca de 70% menos pessoas programando e quem sabe onde estaria o mundo, provavelmente nos anos 90. Idiomas de nível superior atraem uma gama maior de pessoas. Isso permite que um maior suprimento de programadores construa a infraestrutura necessária em nosso mundo. Países em desenvolvimento como China e Índia se beneficiam muito de linguagens como Java. Esses países desenvolverão rapidamente sua infraestrutura de TI e as pessoas se tornarão mais interconectadas. Portanto, meu argumento é que as linguagens de alto nível são populares não porque produzem código superior, mas porque ajudam a atender à demanda nos mercados do mundo.

Estou aprendendo montagem na comp org agora e, embora seja interessante, também é muito ineficiente escrever. Você precisa manter muitos detalhes em sua mente para fazer as coisas funcionarem, e também é mais lento escrever as mesmas coisas . Por exemplo, uma simples linha 6 para loop em C ++ pode ser igual a 18 linhas ou mais de montagem.

Pessoalmente, é muito divertido aprender como as coisas funcionam no nível do hardware, e isso me dá uma maior apreciação de como a computação funciona.

O que C tem sobre um bom montador de macros é o idioma C. Verificação de tipo. Construções de loop. Gerenciamento de pilha automático. (Quase) gerenciamento automático de variáveis. Técnicas de memória dinâmica em assembler são uma enorme dor no traseiro. Fazer uma lista vinculada corretamente é assustador, em comparação com C ou, melhor ainda, com a lista foo.insert (). E depuração - bem, não há contestação sobre o que é mais fácil de depurar. HLLs ganham as mãos lá em baixo.

Codifiquei quase metade da minha carreira em montador, o que torna muito fácil para mim pensar em montador. isso me ajuda a ver o que o compilador C está fazendo, o que novamente me ajuda a escrever o código que o compilador C pode manipular com eficiência. Uma rotina bem pensada, escrita em C, pode ser escrita para produzir exatamente o que você deseja no assembler com um pouco de trabalho - e é portátil! Eu já tive que reescrever algumas rotinas ASM mais antigas de volta ao C por razões de plataforma cruzada e isso não é divertido.

Não, continuarei com C e lidarei com a ligeira desaceleração ocasional no desempenho em relação ao tempo de produtividade que ganho com a HLL.

Só posso responder por que, pessoalmente, não escrevo programas em assembléias com mais frequência, e o principal motivo é que é mais entediante . Além disso, acho que é mais fácil entender as coisas sutilmente erradas sem perceber imediatamente. Por exemplo, você pode mudar a maneira como usa um registro em uma rotina, mas esquece de mudar isso em um só lugar. Vai ficar bem e você pode não perceber até muito mais tarde.

Dito isto, acho que ainda existem usos válidos para montagem. Por exemplo, eu tenho várias rotinas de montagem bastante otimizadas para processar grandes quantidades de dados, usando o SIMD e seguindo a abordagem paranóica "cada bit é sagrado" [citação V.Stob]. (Mas observe que as implementações ingênuas de assemblies geralmente são muito piores do que o compilador geraria para você.)

C é um montador de macro! E é o melhor!

Ele pode fazer quase tudo o que a montagem pode, pode ser portátil e, na maioria dos casos raros, em que não pode fazer algo, você ainda pode usar o código de montagem incorporado. Isso deixa apenas uma pequena fração dos programas que você absolutamente precisa escrever na montagem e nada além de montagem.

E as abstrações de nível mais alto e a portabilidade tornam mais valioso para a maioria das pessoas escrever software de sistema em C. E embora você possa não precisar de portabilidade agora, se você investir muito tempo e dinheiro escrevendo algum programa, talvez não queira se limitar no que você poderá usá-lo no futuro.

As pessoas parecem esquecer que também há outra direção.

Por que você está escrevendo no Assembler? Por que não escrever o programa em um idioma verdadeiramente de baixo nível?

Ao invés de

mov eax, 0x123
add eax, 0x456
push eax
call printInt

você poderia muito bem escrever

B823010000
0556040000
50 
FF15.....

Isso tem tantas vantagens, você sabe o tamanho exato do seu programa, pode reutilizar o valor das instruções como entrada para outras instruções e nem precisa de um montador para escrevê-las, pode usar qualquer editor de texto ...

E a razão pela qual você ainda prefere o Assembler sobre isso, é a razão pela qual outras pessoas preferem C ...

Porque é sempre assim: o tempo passa e as coisas boas também passam :(

Mas quando você escreve código ASM, é um sentimento totalmente diferente do que quando você codifica langs de alto nível, embora saiba que é muito menos produtivo. É como se você fosse um pintor: você é livre para desenhar o que quiser da maneira que quiser, sem absolutamente nenhuma restrição (bem, apenas pelos recursos da CPU) ... É por isso que eu adoro. É uma pena que essa linguagem desapareça. Mas enquanto alguém ainda se lembra e codifica, nunca morrerá!

$$$

Uma empresa contrata um desenvolvedor para ajudar a transformar o código em $$$. Quanto mais rápido o código útil puder ser produzido, mais rápido a empresa poderá transformar esse código em $$$.

Linguagens de nível superior geralmente são melhores para produzir volumes maiores de código útil. Isso não quer dizer que a assembléia não tenha seu lugar, pois há momentos e lugares em que nada mais fará.

A vantagem das HLLs é ainda maior quando você compara o assembly a uma linguagem de nível superior ao C, por exemplo, Java, Python ou Ruby. Por exemplo, esses idiomas têm coleta de lixo: não há necessidade de se preocupar quando liberar um pedaço de memória e não há vazamentos ou erros de memória devido à liberação muito cedo.

Como outros mencionados anteriormente, a razão para qualquer ferramenta existir é a eficiência com que ela pode funcionar. Como os HLLs podem realizar os mesmos trabalhos que muitas linhas de código asm, acho que é natural que o assembly seja substituído por outros idiomas. E para as brincadeiras próximas ao hardware - há montagem em linha em C e outras variantes conforme o idioma. O Dr. Paul Carter diz na Linguagem de Montagem do PC

"... uma melhor compreensão de como os computadores realmente funcionam em um nível mais baixo do que em linguagens de programação como Pascal. Ao obter uma compreensão mais profunda de como os computadores funcionam, o leitor geralmente pode ser muito mais produtivo desenvolvendo software em linguagens de nível superior, como C e C ++. Aprender a programar em linguagem assembly é uma excelente maneira de atingir esse objetivo ".

Temos introdução à montagem nos meus cursos da faculdade. Isso ajudará a limpar conceitos. No entanto, duvido que algum de nós escreva 90% do código na montagem. Quão relevante é hoje o conhecimento aprofundado da montagem?

Ao folhear essas respostas, aposto que 9/10 dos respondentes nunca trabalharam com montagem.

Esta é uma pergunta antiga que surge de vez em quando e você obtém as mesmas respostas, principalmente desinformadas. Se não fosse pela portabilidade, eu ainda faria tudo em conjunto. Mesmo assim, eu codifico em C quase como fiz na montagem.