You can write Perl in Latin or Klingon:

Latin from https://metacpan.org/pod/release/DCONWAY/Lingua-Romana-Perli... :

  use Lingua::Romana::Perligata;
 
  adnota Illud Cribrum Eratothenis
 
  maximum tum val inquementum tum biguttam tum stadium egresso scribe.
  da meo maximo vestibulo perlegementum.
 
  maximum comementum tum novumversum egresso scribe.
  meis listis conscribementa II tum maximum da.
  dum damentum nexto listis decapitamentum fac
      sic
          lista sic hoc tum nextum recidementum cis vannementa listis da.
          dictum sic deinde cis tum biguttam tum stadium tum cum nextum
          comementum tum novumversum scribe egresso.
      cis

Klington from https://metacpan.org/pod/Lingua::tlhInganHol::yIghun :

  use Lingua::tlhInganHol::yIghun;
   
  <<'u' nuqneH!\n>> tIghItlh!
    
  {
          wa' yIQong!
          Dotlh 'oH yIHoH yInob 
                  qoj <mIw Sambe'> 'oH yIHegh jay'!
          <Qapla'!\n> yIghItlh!
  } jaghmey tIqel!

Congratulations! You have discovered the absolute nerdiest activity on the planet. Writing Perl in Klingon.

Writing Perl is enough.

Qapla!

I had completely forgotten about this and honestly laughed out loud. Learn some more at:

https://www.youtube.com/watch?v=auqS6FR_RDE

We must inform the Klingons immediately.

I don't understand Latin at all but I picture a centurion dictating this to a scribe, chiseling into stone, soon to deposit it in a Flintstone-ian rockputer.

I love the Latin one, looks like a magical incantation :)

It's too sad the latin one is not updated since 2001, I would love to use it to write random personal pieces of code!

I don't know any Lisp, but I wonder about doing something like this in one, since if I understand correctly, even things like conditionals are functions. I'm sure it would be possible with macros, but I wonder if you make a Chinese Lisp just by redefining functions.

Indeed!

https://elangocheran.com/2014/10/30/exploring-programming-in...

https://youtu.be/MqjMZNwnYCY

Although I started the above project around the same time as Ramsey started his project in the original link (CLisp in Arabic), they were two entirely independent things. Ramsey's project is a 100% translation, whereas my project scales to other natural languages but is not a 100% translation.

Tim and I worked on trying to make programming in other languages easier as a means to help more kids learn programming, and learn FP the Lisp way, which we explain as more natural.

https://www.youtube.com/watch?v=Y3-53JoGPE4

https://power-turtle.com/#freestyle

Conditionals are not functions in Lisp. They are 'special forms' since they have to control the evaluation of their arguments and functions always evaluate all their arguments.

So, if you want to translate a lisp into another language you have to resort to macros.

None and none, as what you need is to alias the symbols for most lisps.

Been a while since I've done Lisp seriously, but I don't believe that's possible, at least in Common Lisp (SBCL). While if responds to symbol function:

  * (symbol-function 'if)
  #<CLOSURE (:SPECIAL IF) {1000C5084B}>

SBCL refuses to set that value to an alias:

  * (setf (symbol-function 'foo) (symbol-function 'if))
  #<THREAD "main thread" RUNNING {10005205B3}>:
    #<CLOSURE (:SPECIAL IF) {1000C5084B}> is not acceptable to (SETF SYMBOL-FUNCTION)

Trying this with regular functions works as intended:

  * (setf (symbol-function 'bar) (symbol-function 'mapcar))
  #<FUNCTION MAPCAR>
  * (bar #'1+ '(1 2 3))
  (2 3 4)

Special forms are, well, special and a lot of the regular parts of lisp doesn't work with them.

hmm, I think worst case symbol-macro should work there :/

I expected specials to work in this case, but apparently not.

Yes; alias the symbols that are macro operators or special operators via macros, and alias other kinds of symbols in their respective namespaces.

Variables may also have to be done with macros, because you want an assignment to a translated variable name to appear in the original variable. Some Lisp dialects perhaps allow a variable cell to have a binding to two or more symbols which could do the same thing.

Uses English grammar, though.