Rouille – Rust Programming, in French | Hacker News Reader

Rouille – Rust Programming, in French

github.com

216 pointsmihau157 comments

As a native french speaker, I feel so uneasy reading source code in french. It feels very very uncanny. I've often wondered if English native speakers feel the same when reading normal source code which is always in English. They probably don't. But how? I've always associated the "other language-ness" to correctness and technicality. It must be so weird to code in your own language. Feels like reading bad pseudo code. It's very nice to be able to map "english" to "technical, correct" and "native language" to "descriptive, approximate, comments, pseudo-code". Having only a single language to work with is like removing a color from the rainbow.

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.

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 .

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

Most programmers probably don’t even know what that means.

It looks more elegant than English.

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.

I'm quite fluent in english and "unless" is also weird to me, for some reason, "when" in ansible is also very weird, I don't know why. Back to the original post, I would never work for my (French) government again if they adopt something like rouille ; just reading the README felt very weird.

But rust lets you use unicode for identifiers. Just make every variable its own greek letter. Or Tamil, plenty of languages available. Why waste screen space by using entire words? That is mostly sarcasm, maybe?

Didn't someone say something about using French to speak of love and german to speak of science? Maybe english is getting it's use.

> But rust lets you use unicode for identifiers. Just make every variable its own greek letter.

This can actually be useful for locally-defined variables. Even more so if you're using an editor with LSP support where it's trivial to bring up the doc comments for an identifier as a tooltip - with some added support, you could even write these doc comments in multiple natural languages, while keeping the code itself quite linguistically neutral.

> Didn't someone say something about using French to speak of love and german to speak of science?

Possibly a quote attributed to Charles V: I speak in Latin to God, Italian to Women, French to Men, and German to my Horse.

> Didn't someone say something about using French to speak of love and german to speak of science? Maybe english is getting it's use.

That's interesting - as someone noted below, in musical notation, the keywords are nearly all Italian, and it would feel quite weird if they were written in English instead. So in that sense, yeah, maybe `for`, `if`, `then`, `import`, etc. are the "fortissimo" and "d.s. al coda"s of the programming world.

> "unless" is also weird to me

I think that’s because it (¿almost?) always splits “is not” in two parts. Compare “If x is not y” with “if not (x is y)”.

> for some reason, "when" in ansible is also very weird

When feels weird to me, too. I think that is because “when” often implies something will happen, but you don’t know the exact time, while “if” means you don’t know whether it will happen at all (compare “when it rains” with “if it rains”). So, using when to describe a trigger is fine, but to me it doesn’t make sense as a statement in an imperative programming language.

> just reading the README felt very weird.

I had to check, and yes, there is a README.md, and no LIVREMOI.md.

Wouldn't that be LISMOI.md ? [edit] nope - apparently LISEZMOI.md

Possibly. My French isn’t that good.

Going to go with "yes" based on this 2nd hit in a DDG search :) https://gitlab.com/bztsrc/easyboot/-/blob/main/LISMOI.md?ref...

[edit] n/m based on correction below and followup search, there are far more LISEZMOI.md files than LISMOI.md files.

It would be LISEZMOI.md

Unless When

I guess you will not like Lisp then (;

http://clhs.lisp.se/Body/m_when_.htm

I’m not a native speaker, but I always liked the postfix “unless” in Perl, for use with operations that are performed in the common case and only omitted under special circumstances.

    do_something() unless special_condition;

It vibes with “unless” in English usually implying an exception.

PERL was too clever by half, but if you leaned into making it readable, there were lots of tricks that could help.

    do_register() unless invalid()
    do_send_email() unless email_down()
    do_login() unless password_to_short()

... it wouldn't be the way you'd do it today, but if used "tastefully", they were helpful!

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.

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.

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

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

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.

For real though! I could get used to &ipse.

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

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?

Yes we do this while learning programming. Then it quickly becomes a sign of being a novice programmer that we look down on.

Should it be looked down on?

I think so. You don't know who might touch your code later, better to use English than for them to figure out what those words mean. It would be like using giberish for all your variables.

Another issue, even for other speakers of your language, we don't all translate english words the same, some words are just not translatable and some words look the same but mean different things, how can they tell if it was meant to be English or not?

For example in Spanish, "default" translates to "por omisión", two words, there's no single word for it, a lot of people translate it to "defecto" because it's similar but that means flaw, defect. It's so used, people say "por defecto" instead of "por omisión" now and some dictionaries added it as a translation already.

Another example, "cache", I know its meaning in computer lingo, the times I've had to use it is in the context of computers, so I have no idea what its translation to Spanish is or if there's even a word for it. If someone used the translation in code I would have no idea what I'd be looking at.

One more, "library" translates to "biblioteca" but some people use "libreria" (bookshop) because it sounds similar. You can find usages of both in documentation. People will probably understand both but it hurts searchability.

Well. Although this rouille thing is obviously a joke, it's also just a preprocessor macro layer, so it'd be pretty easy to switch to any view of the code. Could write it in "french" then transform it to english, then to russian.. Could also imagine doing that in an IDE without even impacting copy and paste just as a visual layer. Not sure what one would do for that spanish por omisión, but maybe just put an underscore. por_omisión

For another example of this, there was BritCSS someone made that lets you use British spellings in CSS:

https://github.com/DeclanChidlow/BritCSS

Yeah it's quite common in French (for learners). At least in part because French people aren't very good at English, it'd add more friction to the learning process (and even for the ones who aren't bad at english, it's a whole new vocabulary to learn).

I'm not sure when I did the switch myself! Maybe as late as my first professional experience, or maybe a bit later in my studies

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

I don't know anything about the Portuguese script. But your example seems to be made entirely of regular Latin alphabets. Now imagine another language where that isn't the case. Just switching the layout even on a programmable keyboard is going to be a major annoyance. I can touch type on two layouts (English Qwerty and Malayalam Poorna Inscript, in case you're wondering). Occasionally switching between the two layouts is the biggest distraction while typing prose - even with convenient layer switchers programmed in. Programming is going to be hell if the keywords and identifiers are in different scripts. I reckon that it would slow me down to about one-third of my full speed.

There are genuine reasons why identifiers could be in another language - like programming for linguistics (spelling and grammar checkers, morphology analyzers, etc) or while dealing with regional concepts. But even in those cases, programmers simply transliterate it into Latin script, rather than use the original script. Their sound roughly the same. But full fidelity is not possible (there are sounds that you may not have even imagined before). Even so, it's easier to just compromise on fidelity rather than do constant layout switching.

And then there is the reality that many language scripts are simply unusable for programming. My own language is agglutinative - meaning that multiple words fuse into one (even 4 words combining is not unusual). The same thing can be written in a dozen different ways. This isn't a big issue if you're reading or listening. It won't confuse you. But the moment you start applying formal rules like in a computer, it's a dozen different ways to type it wrong! I like my script for anything other than programming. It's very expressive. But the anemic simplicity of the Latin script is actually a big advantage when it comes to things like programming and mathematics. I believe that you will find many such peculiarities and nuances with other scripts if you go searching.

> your example seems to be made entirely of regular Latin alphabets.

Portuguese is a direct descendant of Latin. But it has quite a bit of punctuation, OP just ignored that as the programming language, C, does not support it. In Common Lisp you can happily go:

    (when verificação (print “pessoa é maior de idade”))

You could even go all the way:

     (defmacro quando (cond corpo) ‘(when ,cond ,@corpo)
     (defun imprime (x) (print x))
     ; now we can do this
     (quando verificação (imprime “pessoa é maior de idade”))

Ah! Yes! I was wondering about the diacritics/accents. How do you deal with those? Do you have to switch keyboard layouts like me, or are they trivial additions to the qwerty layout?

I have 3 different keyboard layouts installed. As I live in Sweden, my keyboard shows the Swedish layout, but I also use both English and Brazilian ABNT layouts and know them by heart.

I have a single key shortcut to switch between them.

Accents work as if I was using a native keyboard, so they're not too bad (unless you're on mobile, there it sucks), except the keys do not show the right symbols. If you don't know the mappings by heart, you can get your OS to show you the layout... maybe leave that on the side and look up when you forget something.

If the application domain is country-specific, this even happens in professional programming, because it doesn’t make sense to invent English translations for the local-language domain-specific technical terms. Whenever people do this, the result is non-idiomatic English terms that neither make sense to an English speaker nor to a local domain expert.

When learning a new computer language, using names in your native tongue makes it easier to tell what's yours and what belongs to the programming language itself.

Now when syntax highlighting is everywhere language separation doesn't give much benefit.

People do it and it’s perfectly fine.

There is nothing mandating you have to write things in English. It’s often but not always the de facto common languages between foreigners but it’s just a language.

If you read the code of Chinese projects, it’s very often in Chinese for exemple. They don’t really care about English speakers.

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

Two of the best things I learned in French class (which was basically “Parisian culture of 1982” class) was that “impossible” in French meant “I don’t feel like it”, and if someone shrugged in a way where the edges of their mouth touched the top of their shoulders, you were shit out of luck with whatever you were asking for.

Off-topic but that reminds me of the quote from "Stand on Zanzibar" where 'impossible' is defined as IIRC "1) I can't be bothered or 2) I don't approve or 3) God can't be bothered"

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.

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.

This is a very good analogy, sheet music with all the Italian replaced by English would be very funny. "Loud!" "Very loud!" "Super-duper quiet!" "This is the end of the song!" "play this part reallll smooootthh" etc.

(Actually I believe the late P.D.Q. Bach [1] did this a lot, and it was in fact quite funny)

[1] https://en.wikipedia.org/wiki/P._D._Q._Bach

How's Microsoft Excel for you?

Excel is a good one, another one is World of Warcraft macros which depend on the client language because Blizzard is too good at i18n and they translated spell names which are used as spell identifiers in the UX lua code.

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.

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

"Class" in the sense of classification and taxonomy is a common English word used in many contexts: working class, second class, business class, etc. Those aren't obscure concepts. I don't think it is any more weird than "if", though I am not a native speaker.

Years ago a read an introduction to category theory, and it was very obvious that it influenced object oriented programming.

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.

L’ordinateur really should have caught on, it’s a pity. A beautiful word.

Computer comes from French, so they could just have settled on pronouncing it properly and gotten on with their day, but nooo, gotta invent a new word for this very old french word.

My first language was also Logo, which I learned first in English at home, then in French at school. I wonder how many languages Logo was translated into?

Examples is French: https://www.tortue-logo.fr/fr/tortue-logo/exemples/

Mine was exclusively in Polish because it was some kind of demo version which lacked documentation and some functions.

Fortunately most commands had TLA aliases and were highlighted in the editor, so I just generated all three-letter combinations, inspected them visually and reverse-engineered what they were doing.

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

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.

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!

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.

The complete dictionary is here: https://github.com/bnjbvr/rouille/blob/principale/rouille_co...

I just can't stop laughing at the "génial" => "super" https://github.com/bnjbvr/rouille/blob/principale/rouille_co...

Haha the translation is so funny. But I confess, as a native french speaker, I could not code in that language. It is so weird because I am used to english for coding now. Sometimes I write my variable names in french and I think I even used accented letters one time. What is worse, is that I tend to mix english and fench variable names in my code, but anyway english is way more common in the code base.

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 find it slightly disappointing that they haven't stuck with the Rust practice of picking short or abbreviated words when they're clearly unambiguous - such as "fn" instead of "func" or "function". E.g. why Résultat<...> when you can write just Résu? Why PeutÊtre and not Ptêt, very common in quick language, e.g. for texting or chatting?

I've notice there is "merde" method which is available in the example like in https://github.com/bnjbvr/rouille/blob/7e9523fe24026bff1a3a7...

Merde is an alias for "calisse" and "oups" , see https://github.com/bnjbvr/rouille/blob/7e9523fe24026bff1a3a7...

I'm partial to crate -> cagette

"PeutÊtre" => "Option" is the clearest evidence this is shitposting, because Option is also a French word.

But the best one is "merde" | "calisse" | "oups" => "panic"

lol, the author (or whoever translated) doesn't know that "super" doesn't mean "génial" in the context it would be used in.

"super" is also a Latin word that's valid French.

> Au-dessus de, exprimant une supériorité dans la qualité

https://www.larousse.fr/dictionnaires/francais/super-/75409

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

Yeah that was my understanding and why I found it so funny!

It’s intentional and meant as a joke.

I might have picked "desu" as the keyword, a shorter phonetic respelling of dessus. Since the super keyword is often repeated in Rust, this would lead to code like `utilisons desu::desu::desu::a()`, for some added Japanese flavor.

Even so, it parallels a real thing that happens in non-joke contexts, where they avoid valid French when it looks "too English":

https://news.ycombinator.com/item?id=45773624

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".)

I don't understand any of this.

Probably because of their proximity with the USA, the french-speaking community in Québec is far more attached to using French than actual French people. That's why in France we use "Stop" and not "Arrêt".

On the other hand, ".gouv.fr" is something used in France. gouv[ernement] is completely different than go[u]v[ernement] Not only because of its pronunciation, but also because it's not a simple shortening of the original word.

We never use "aso" to talk about an "association", even though it would shorten it even more, because it just doesn't make sense. You can remove the ending of a word, creating a kind of "prefix", bug it you remove multiple part of a word it just become something different.

>On the other hand, ".gouv.fr" is something used in France. gouv[ernement] is completely different than go[u]v[ernement]

How are they different? Contractions and abbreviations drop letters. That's the point. .gov would have been perfectly fine and matched other countries. It's a clear example of being different for the sake of it.

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()) } }

https://github.com/michidk/rost

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())
            }
        }

isn't the idea behind programming "languages", that they are sentences readable to both humans and the compiler?

This absolutely is not readable to me. But woerterbuch and schluessel should of course not be abbreviated, for legibility.

If German was seriously used in programming languages, I'd hope for some better and shorter terms. Some here might be intentionally too literal translations anyway. "Let" is from mathematics, it's called "Sei" in German. "Sei x = 5". "Anderenfalls" could be "sonst". "Zeichenkette" is just too long and would require some thinking or a historical accident to find a shorter term.

Ready surprisingly nice to me anyway.

I would use "sei" instead of "lass" for "let" to be more in line with notation in mathematical proofs.

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

I read it as als_referenz, which arguably makes sense!

For sure it's valid German but for maximum fun it's nice to have it be as Germanic as possible and avoid words that share roots with the standard English programming terms.

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

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)

You must learn about Baguette#.

An implementation of OCaml (similar to Haskell, but from France instead of UK), but with french pastries name. It was half a joke, half a serious study project.

https://github.com/vanilla-extracts/ocaml-baguettesharp-inte...

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/

Listen, if you didn’t just spend at least 5 minutes trying to make random foreign accents reading the code to yourself out loud trying to figure out what the code does…

We’re different people.

Previously discussed:

Rouille (338 points, 144 comments, Sept 11, 2021) https://news.ycombinator.com/item?id=28490935

Rost – Write rust code in German (55 points, 16 comments, Nov 9 2021) https://news.ycombinator.com/item?id=29159077

Rost – Rust Programming in German (161 points, 115 comments, Mar 25, 2025) https://news.ycombinator.com/item?id=43488490

I like the translation of the WTFPL as « la license rien a branler »

If you don’t know the idiom, you should check it out, it’s both particularly vulgar and very commonly used.

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

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

I like to imagine a world, a worse one, where programming languages were localised. This might initially have been a versioning nightmare, with different compiler binaries for each localisation. Later, it could become standard practice to ship a single compiler containing all supported localisations, the correct one being chosen from either system language, a project-wide setting, a preprocessor flag in each file, or some combination of these. Everyone would have to learn a little Polish, and "Source Code Translator" would be a profession.

You mean excel?

Hah!

Reminds me of the first time I tried Excel in English (might have been Google Spreadsheet) and the searchv function was nowhere to be found, not knowing it was actually called vlookup ("buscarv" in Spanish).

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 can serialize ASTs very easily as S-expressions, or slightly fancier versions thereof. That's still "text" and quite easily readable by humans, but somewhat less oriented to direct editing.

I would love for the block delimiters to be also a preference, like the language in that world. I'd edit every language with Python style blocks.

Name conflict with the OG rust synchronous web framework: https://github.com/tomaka/rouille

There were actually localized version of Visual Basic for Applications.

https://de.wikipedia.org/wiki/Visual_Basic_for_Applications?...

https://news.ycombinator.com/item?id=21352796

Is the compiler now gonna scream at me for using the wrong gender?

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())

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

Without the proper -—bonjour flag as first argument, I expect the compiler to work against me, pretending to compile fine while introducing subtle users bugs

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

Related: Non-English-based programming languages https://en.wikipedia.org/wiki/Non-English-based_programming_... (not really up to date though)

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.

Unfortunately it still uses a dot for the decimal point.

sacrebleu

This is very lenient French: "fetchez le dico"

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

This is hilarious, thank you for your effort good sir, this is what I pay the internet for! :)

I was curious fairly recently if programming languages could support keywords in multiple languages. My mental experiment wanted to have translation resource files, mapping keywords or the concepts they represent (if, then, for, while, func, struct, etc) to a localized human language. You could code in your native language, and so could your international fellows - the file is translated in the editor

It got complicated fast. Now you need a canonical representation for disk, something still text, maybe English is the common denominator? Do variable names get translated? Etc

I would like to see it tried, but I’m not brave enough.

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

The Russian version linked there is, uh, underwhelming. That whole gopnik vibe is entirely unwarranted. I understand a bit of Spanish and that one is much better in comparison.

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

Slovak one does not use diacritics so it’s quite hard to read.

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

idk, as I see it - it's funny if you are 14 years old or non native, so the whole vibe is a bit amusing.

Just like it may be amusing to watch "Don't Be a Menace to South Central While Drinking Your Juice in the Hood" as long as you understand satire.

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

This is excellent.

This is amazing.

BTW, here's the stream to go along with that:

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

The small cyrillic letters in the rust example are oddly appealing to my eye. Kinda like smallcaps in a latin script

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

"Rustic" is actually a very common term in the Rust community, though it's an obvious joke drawing on 'Pythonic'. But there's nothing inherently wrong with "Rústico" as a name for a programming language.

That's all well and good, except the README clearly states:

> rústico (Spanish for Rust)

which is plain wrong.

It’s funny because it forced me to consider how I would translate some of the keywords when reading the code.

Some of the choices seem debatable. I’m not sure I would translate Some/None this way. The second person imperative for Use feels very weird to me too and I don’t think using vulgar French is adequate.

I really like "convention/réalisation" however.

Funny, I was just thinking the other day that as a C/++ programmer, writing TypeScript feels a lot like speaking French where nouns and adjectives and verbs are all in the 'wrong' order. It's a very strange feeling, exactly like learning French as an English speaker

There is also a Rust minimal HTTP server by this name. (Incidentally, one of the few that isn't Async.)

That reminds me of LSE, a French BASIC-like programming language.

https://en.wikipedia.org/wiki/LSE_(programming_language)

Fantastique !

Let's create "Piaf" to see la vie en rose, the French à la https://codewithrockstar.com/.

This is fun. My son is learning esperanto, is there a version for that, maybe a weekend projekto for him.

https://github.com/dscottboggs/rustteksto

It's interesting how coding in your own language can make the logic feel completely different.

hahaha j'adore que le mot québécois "calisse" est inclus

Be sure to look at the "other languages" section; and then wonder whether all of it was generated by AI.

It definitely was.

I don‘t think so. At least the french one is quite old and was discussed here before AI was in wide use: https://news.ycombinator.com/item?id=28490935

I remember that many of the other languages popped up a little later.

I doubt it. Rouille uses a very simple "word to other word" map that anyone with an hour of free time can fill out for their own language.

The implementation is also rather inefficient, but it's not like such a translated macro will be used for anything serious.

The Russian version seems to be handcrafted with humor

I can tell you that github.com/jeroenhd/roest was all done manually.

If I'd used AI, I probably would've included grammatical gender for nouns.

Not surprised this sort of thing pops up specifically for french. France is known to not speak English in some situations even though they know English.

Just wait until the Quebecois government here in Canada hears about this. They are militant about avoiding english at all costs. They changed all the STOP signs in Quebec to ARRET because STOP was too english.

What's wrong with that? You want more Anglomania?

Whenever I try speaking French to them they stare at me in horror and immediately switch to English.

I’ve had the same experience.

It’s just as well because when native speakers reply, I can’t understand them. The words are too smeared together for me.

OTOH, when a non-native French speaker (who may not know English) speaks fluently in French, I can actually hear each word and understand them easily.

C'est dégoûtant.

L'Horrible

next up, rust in ebonics

Currently computer programming is done using one's knowledge in mathematical language(or mathematical way of thinking) + knowledge in English. It would be nice to see how replacing the English part with mothertounge work. For me, atleast I can read the documentation with confidence and much ease(I'm not French btw). And may it become an experiment to see how it works for non-English languages. Thanks for the French to starting this. I was once wrote in my blog about programming in my own mothertounge which is Malayalam.

Reply on news.ycombinator.com