I'm a native English speaker. I do actually remember programming languages feeling a little uncanny at first. Like you can tell that it's "computery" and that the language author tried to make it English-like and only sorta succeeded.

So I think at this point, for me, programming languages just aren't English. One odd thing I've noticed is that in Ruby the `unless` keyword confuses the hell out of me, and yet when speaking English I never get tripped up on the actual word "unless". So I guess it's handy that the keywords in programming happen to be English words, but my comprehension of programming languages seems to occupy another region of my brain.

    do_something() unless special_condition;

The closest I've ever felt to this as a native English speaker is reading words in music scores in English. I'm a classically trained cellist, and grew up learning notation with Italian and French words for directions and expression. I've never learned either of those languages, save the words used in music notation. Seeing a score with those words in English just feels... wrong. Not in any big way, but as you said: uncanny. Definitely get the "bad psuedocode" vibe, because to me it English in music notation feels similar -- like the person who wrote it didn't know what they were doing, even though the notation makes perfect sense and the music is good. It removes some of the flair of the art of the notation itself for me.

(Brit here) My first encounter with a foreign PL was a French Prolog implementation in the mid 80s whose only compiler error message was IIRC something like 'Erreur syntactique'. This seemed superbly Gallic, if somewhat less than helpful.

For anything vaguely technical, I use the English term. I don't feel comfortable in any other language, no matter how well I speak it. It just doesn't sit right with me to use eg a Danish term for density, or power, or eigenvalue, or anything programming.

Part of it is that even though I might know the term, it won't be long before I need to bring in something where I don't know the term. At that point I'll be inventing a local term, when I know what the English term is.

In this particular case, it might also feel uncanny because the keywords were merely translated; but the grammar (most notably word order) doesn't (always) match.

`asynchrone fonction` feels wrong because it's the wrong word order for French; it should be `fonction asynchrone`...

I'm a native Portuguese speaker. Here, when people are first starting to learn programming, it's very common for them to write code in Portuguese. For example, they would write this simple age verification algorithm:

  int verifica_idade(int idade) {
    if (idade < 18) { return -1; }
    return 1;
  }

  int main() {
    int idade;
    scanf("%d", &idade);

    int verificacao = verifica_idade(idade);
  
    if (verificacao < 0) { printf("Acesso negado\n"); }
    else { printf("Acesso liberado\n"); }

    return 0;
  }

Do French (or other languages) speakers also do this?

I started self-learning programming from Swedish resources, using Swedish variable names and (trying) to store Swedish text in databases. The good news is that I learned about encoding and how to store "åäö" properly early on, the bad news is that it was really difficult to ask questions on Stack Overflow when your PHP is 50% Swedish and 50% English. Actually entering the code into Notepad++ was difficult too, weird finger movements to get to the common "special" characters.

Since them I've moved to US keyboards after starting to work with others in an office and not being able to pair program otherwise, and obviously default everything else to English too.

I'm not a native English speaker, but when I come across that sort of "programmed in the country's language" programs today it does take some time to get used to the style and translating stuff while also trying to understand the logic. I wouldn't say it's a huge time-sink, but particularly names can be difficult to convert/translate on the fly when you're trying to get product and developers to agree to what we're talking about.

As a native french speaker, I have the same feeling when reading code written with french keywords, except that since I learned boolean and arithmetic in french, it makes more sense to me to read them in french. As others have pointed out, it seems to only be a matter of how you learn to read and write code.

For comparison, in mathematics I learned to read all the symbols in french, and only learned their english equivalent much later, so it feels uneasy for me when i read their english version. So it is clearly a matter of habit that took its root when you learned reading.

As an American...no uncanniness to English. I guess because it was always the default and what was taught.

The first time I encountered a non English PL, I did feel the same uncanniness you spoke of. It felt... wrong? I wish I remembered which one it was. It was probably the first time I realized how prevelant English was, and that PLs could even be written in any language .

The first language I gained any proficiency in was Logo which, as an educational tool, was translated to my language and that felt to me like a 1960s understanding of communicating with an AI.

I learned English via immersion as I was thrown into an international environment at age four and to me it radiated confidence as the few native English speakers there were obviously much more proficient in the language.

I have a problem with the word "robot", as it's essentially a loanword from my family of languages, but I was unaware of that initially and once I've made that connection, the "coolness" faded somewhat.

Strangely French to me has this same air of confidence, displayed in, among other, the French word for "computer". Truly the French copy no one, nobody copies the French.

It did not feel odd to me.

Possibly a remnant of being bilingual as a child (I am not anymore, and was not by the time I learned programming later in my childhood)?

I do not think I ever really thought of programming languages as being English, but English like/derived from English.

> I've often wondered if English native speakers feel the same when reading normal source code which is always in English.

I think that depends on if they understand how to program. For me, as a native English speaker, a computer program is not speech.

In a program, there's three areas where the spoken language influences:

1: The keywords in the language: IE, "if," "switch," "return," ect. These take on a meaning in my head that is distinct from the meaning of the spoken word. "class" is a good example: Its use in programming is shortened from "classification" which comes out of category theory; but its use in English means something very different. Likewise, "if" in my head has such a different meaning in code that if "si" were used, it wouldn't make a different.

IE, in code we use "class" as if https://en.wikipedia.org/wiki/Class_(programming), which came from https://en.wikipedia.org/wiki/Class_(set_theory) and https://en.wikipedia.org/wiki/Category_theory; but in English it's commonly meant to be https://en.wikipedia.org/wiki/Class_(education).

2: The API names: By convention, APIs typically are English. Learning these is like learning any kind of professional lingo. I've never tried using a non-English API, and would probably struggle significantly if I had to.

3: My code itself: A significant amount of my time spent writing a computer program is making sure that my code is understandable to me and the other people who have to maintain the program. There's always going to be an "other-worldliness" to a program until someone understands the conventions and style.

Native French speaker here as well. I hate with all my heart technical places where French is fed to me without an easy way to switch to English.

I then spend an unholy amount of time translating the words to English, trying to hit the right traduction.

Despite loving my language and defending it in normal situations, Internet and dev is in English and this is life.

Yes it's so strange, like bad and unreadable pseudocode.

I could see myself coding in Latin though: https://github.com/pianoman911/ferrugo. Something about the prepositions tickles my brain the right way.

I've worked with Japanese and German code. It is definitely unfamiliar and gets me thinking a lot more about how I approach code. I'm liking your description as I keep wanting to map "english" to "technical, correct" too and this helps. thank you!

I think you may be over-reading into this a bit. Seems to me as just a familiarity thing?

Programming in English = X Programming in French = Y

You're used to X and now it's Y. So it feels weird. English speakers are used to X and it's X. So it feels normal.

It is uncanny but in that case I had a fun feeling reading usual abstraction (maybe types, self traits) in French, it tapped into a different part of the brain, that helps thinking about what the code means less mechanically

Salutations,

I always felt the same and one theory I have is because the imperative nature of source code feels rude if you try and put it in French. It feels like yelling orders to a dog.

Then I don't know if it's just because in French, despite everyone calling us rude, we are usually quite polite. Or if it's the same for every ESL.

I'm curious if there was a similar dynamic when German stopped being the standard language for scientific research.

The words may be English but it doesn’t feel like English at all because it’s but structured like natural language.

How's Microsoft Excel for you?

It looks more elegant than English.

i thought the verbs in English-programming were meant to be infinitive and not imperative?

I don't like the non-Germanic ref here in als_ref is not Germanic enough. als_ver (from Verweis) would be nicer.

As a non-Bavarian German, I'm offended by the German = Bavarian stereotype! (jk, it's just mildly annoying sometimes and this is meant to be silly)

Almost perfect. I'm missing the Schwabacher typeface rendering.

Indent with two spaces for code formatting.

  fk lese(&selbst, schlsl: Zeichenkette) -> Ergebnis<Möglichkeit<&Zeichenkette>, Zeichenkette> {
            wenn lass Etwas(wöbu) = gefährlich { WÖRTERBUCH.als_ref() } {
                Gut(wöbu.hole(&schlsl))
            } anderenfalls {
                Fehler("Holt das Wörterbuch".hinein())
            }
        }

Years ago the research team behind OCaml released Chamelle, a version of the language localized in French, as an April fool's joke:

https://gallium.inria.fr/blog/ocaml-5/

"Nothing to wank license", too literally translated

French has so many perfectly normal looking words for sexual stuff. Not particularly long or short, not a compound of other words or a circumscription... nope, just a word for a thing, like table or house or tree.

But is it more vulgar than the English version? Deep question.

I think if this were the case, we would have quickly moved on from storing source code as text, and begun storing it as ASTs which could be 'viewed' in any localised version of the programming language. This may have had wider benefits than just reading source code in your preferred language.

You mean excel?

This is actually in a very aproachable and lenient french. The compiler will offer you a smoke to cool down and think about your syntax from some distance.

> Arf("fetchez le dico".vers())

Missing!! They should've translated `let` to `le` and `la`.

lol, it'll just say 'Noh!' and then ignore any further input. Especially if you forget the --bonjour flag.

There are Russian and Chinese programming languages. Quite natural. But there are already Hindi programming languages as well. Mind blowing detail! Thank you for sharing this list.

sacrebleu

Might be a Monty Python joke, as in "fetchez la vache!"

You could still use text for raw identifiers (which tends to be very convenient for debugging) but define language-specific alternate mnemonics as part of your language's equivalent of header files. These alternate mnemonics could even just be some specially formatted "doc comments", with the actual text substitution being done by a LSP-like system.

Apple developed French and Japanese dialects of AppleScript evidently. And planned a Professional dialect more like other programming languages.[1]

[1] https://news.ycombinator.com/item?id=32742275

I don't know russian, so I can't judge the quality, but Tsoding's lang might suit you better:

https://github.com/tsoding/good_training_language

I wish the Greek one had a vibe at all, past putting the Rust logo on a gyro. Not even a curse word. You could have some fun with compiler errors and allusions to Oxi Day (which was two days ago).

I thought the Russian version was pretty funny. Thanks for calling it out.

I was immediately put off by the Spanish version when I saw it was called "rústico", which does not translate to rust at all, it means rustic. The Spanish word for rust would be "óxido".

Using French variable names is a great way for me to know this is something I defined, not something which is defined by the environment.

I'm partial to crate -> cagette

I'm pretty sure they know, and that's what makes it funny. There's an entire genre of internet humor based on using incorrect (because of homophone/homograph words) english-to-french translation. For example saying "vérifie les buches" for "check the logs".

Haha there are other cases where there is valid French that isn't accepted in French speaking areas because it looks too similar to English.

1) Quebec wanted "arrêt" instead of "stop" on stop signs, even though the latter is accepted as valid French and used in France.

https://en.wikipedia.org/wiki/Stop_sign?utm_source=chatgpt.c...

2) The use of the TLD .gouv.fr instead of .gov.fr, even though "gov" is a recognizable contraction of the intended French word "gouvernement".

(No, it's not a valid defense that "'gov' would be pronounced differently from 'gouv'": the English TLD .com is a contraction of "commercial", even though the "com" in "dot-com" is pronounced differently from the "com" in "commercial".)

It’s intentional and meant as a joke.