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
eif
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.