Por que os livros didáticos usam pseudocódigo em vez de idiomas reais?

Não. O ponto do pseudo-código é que ele não precisa compilar. Eu posso rapidamente passar os detalhes irrelevantes. Em contraste, mesmo as linguagens que se parecem com pseudocódigo à primeira vista podem ter detalhes pouco intuitivos que apenas prejudicariam o algoritmo. Vamos pegar, por exemplo, Quicksort em Haskell:

qs :: Ord a => [a] -> [a]
qs [] = []
qs (pivot:xs) = (qs smaller) ++ pivot:(qs larger)
  where smaller = [x | x <- xs, x <= pivot]
        larger  = [x | x <- xs, x > pivot]

ou o mesmo em Python:

def qs(array):
  if not array:
    return []
  pivot = array[0]
  xs = array[1:]
  smaller = [x for x in xs if x <= pivot]
  larger  = [x for x in xs if x > pivot]
  return qs(smaller) + [pivot] + qs(larger)

A vantagem em ambos os casos é que este é um código executável e, como tal, pode ser testado, verificado e testado pelos alunos. No entanto, ambos incluem detalhes sintáticos que distraem. Os alunos normalmente seriam mais bem servidos pelo pseudocódigo que ilustra a intenção do algoritmo, e não os detalhes da implementação:

algorithm QUICKSORT(array)
  return [] if array is empty
  pivot ← array[0]
  xs ← array[1, ...] -- the rest of the array without the pivot
  smaller ← [x | x ∈ xs, x <= pivot] -- all smaller or equal elements
  larger ← [x | x ∈ xs, x  > pivot] -- all larger elements
  return [QUICKSORT(smaller)..., pivot, QUICKSORT(larger)...]

Diferenças notáveis:

• Eu posso apenas criar uma sintaxe de compreensão de lista que se parece com matemática, em vez de explicar por que o Python tem for e if aqui.

• Eu não tenho que explicar a sintaxe da linguagem para a concatenação de listas. Por que o Python usa + addition? O que é : em Haskell? Eu posso apenas escolher uma sintaxe que mostre o ponto com mais clareza.

• o tipo de assinatura Ord a => [a] -> [a] é apenas um detalhe de implementação. Embora possivelmente útil nesse caso, as assinaturas de tipo às vezes exigidas por Haskell podem se tornar absurdas.

• Não preciso explicar por que o Python considera as coleções vazias como falsas e o que array[1:] deveria significar.

• Evito que alunos inteligentes apontem que eu realmente deveria usar yield no exemplo do Python.

• Haskell é chato para explicar estruturas de dados mutáveis como tabelas Hash, árvores RB,….

• As coisas começam a ficar muito específicas do idioma quando precisamos de registros complexos para expressar nossos algoritmos. Por exemplo. O sistema de objetos do Python tem algumas surpresas que apenas distraem.

Dito isso, pode ser muito valioso usar um desses idiomas, além do pseudocódigo, apenas rotular cuidadosamente o que é isso.

Não.

O objetivo do pseudo-código é abstrair os detalhes e as complexidades das linguagens individuais para que você se concentre no que o programa deve fazer, e não em como ele faz isso. Com o pseudo-código, você pode criar regras arbitrárias que não precisam estar em conformidade com os requisitos reais de implementação, como fazem as linguagens do mundo real, mas apenas com os requisitos do tópico em questão.