The Latino Programming Language | Hacker News Reader

The Latino Programming Language

lenguajelatino.org

99 pointschespinoza239 comments

I started learning programming before I could speak English well. A programming language using English words isn't a barrier in any way. Those words aren't real English words, they are symbols. Instead of "and" you could very well have "/\" and it wouldn't make the slightest difference. As a non-English programmer you don't think of those as words, just symbols. And that's accidentally closer to the truth and probably even moulds your mind into a shape better suited for such an abstract task. Using "if" and "else" neither requires, nor is made easier by knowledge of what those words mean. (At the time when I learnt it, I knew what "if" meant, but not what "else" did. It didn't bother me in the slightest.)

I recall reading Dijkstra saying that he preferred that the programming languages he used weren't in his native Dutch for pretty much the reason you give.

Presumably the use of Greek letters in traditional mathematics doesn't present an insurmountable barrier to non-Greek speakers.

While I agree that you learn to treat them as symbols, it certainly elevates the barrier of entry. I know what “while” means in English, so when I’m reading code, there is less of a mental load to interpret that code. As a beginner, if I had to translate “while” or “throw” or “parse”, I’d make learning more difficult.

It's not that you would translate them though. You don't have to know what "while" means in english to use it. You just learn that the arbitrary symbol "while" is how you repeat something as long as a condition holds. There's not really anything language-specific about that, except that "while" happens to be a word in English with a meaning which somewhat correlates with what the symbol does in the programming language.

Counterexample: as a beginner, I think knowing English made "for" harder to understand: for loops in C don't seem to bear much relation to the meaning of "for" in common usage: yes, there is a condition that initiates the loop, but what about the other two statements? For me it was actually something I had to de-program from my brain before I could understand how they actually worked.

I think it's rooted in mathematical phrases like "for all x in the set S..."

Interesting. I suppose you are probably right, but I would still argue it's confusing and doesn't actually line up with the semantics of the C-style for loop. If it were a language like Python, wherein collections can actually be iterated over with a "for ... in ..." statement, then it might make more sense. But the C for loop just has an initializer, a break condition, and a statement executed between loops, so there's not necessarily a connection to the mathematical notation, even if it's often used to execute some function over a collection.

I was curious so I did a bit of historical research.

The "for" loop comes from ALGOL[0]. In ALGOL, the FOR statement supports syntax like "FOR V:= AEXP1, AEXP2,... DO". That's like the higher-level iterator syntax, except it's assigning V via iteration over a sequence of expressions (AEXP N) that is fixed at compile time. That's the context where FOR makes sense as a term. (Step 1: thesis)

Now, ALGOL also happens to support a FOR-STEP-WHILE format, which works the same way as the C for-loop[0]. That makes less sense from a mathematical nomenclature perspective, but it is justified through analogy to the original FOR definition.

When C, which was based in part on ALGOL, implemented for, it dropped the original meaning and kept the special case meaning because the latter was more useful, being dynamic instead of fixed at compile time. Hence, the for loop. (Step 2: antithesis)

Eventually other languages implemented for with iterators, returning to the original ALGOL meaning of for, but synthesizing it with the dynamism of the C for loop. (Step 3: synthesis)

[0] https://public.support.unisys.com/aseries/docs/clearpath-mcp...

Disclaimer: references to the Hegelian dialectic are for entertainment purposes only.

That's the problem though, a C for loop doesn't really work like that. We only recently got something close with the "range-based for" in C++, and while python's list comprehensions do pretty much exactly what I think mathematical "for" should, it re-uses the keyword in different ways elsewhere.

How recent an innovation this is depends on your language.

It was added in C++11 so it looks recent there. But the syntax was in Perl 4 back in 1991. And someone who knows programming history can probably find older examples still in other languages.

I think "for" works better linguistically when taken in the context of a "for-each" loop, where my mental pseudocode becomes "for each of these, do this." It's a touch Yodalike, but it gives me a clearer expectation of what's happening and how long it's going to happen than I get from a C-style for loop.

"while" describes itself particularly poorly for native English speakers. It implies a duration that continues until a condition changes, but really the condition is only checked at the beginning of every loop. English speakers have to get over the incongruity using a word for a contiguous period of time to indicate repeated checks at distinct points in time.

Just speaking personally as a native English speaker, I don't remember ever having expended any effort to get over that incongruity.

I think it's something that only makes sense after the imperative model clicks. There are a lot of different ways that a beginner might think about what code means, and some beginners write code like this:

    while guessing == true:
        ...
        if is _correct(answer):
            guessing = false // This stops execution and jumps out of the loop, right?
        answer = next_guess()
        ...

    // answer should be correct now
    print('Correct answer is %s' % answer)

The program says this block of code executes "while" guessing is true. How does it make sense that code inside the loop is still executing after guessing is set to false? For you and me, since our brains have been molded to the the imperative model of programming (execute this line, then this line, then this line,) we understand that "while guessing == true:" is a line of code that only has effect at specific times, "when the program gets to it." That is not what "while" means in ordinary language, so it's confusing for a beginner until the imperative model is really locked into their heads.

I completely agree, this probably only makes people have to re-learn things when they switch to a more common language, only delaying the process of learning english more and more, when it is something more than necessary, not just for code, also to move around the internet and search for information. I learned english after learning to code and honestly, it was never a problem, as you say, you just learn those words as "symbols" that represent a behavior, nothing more, but, learn different "symbols" and then move on to "standard symbols" such as a while, return, for, etc. will require an extra effort that seems unnecessary to me.

> A programming language using English words isn't a barrier in any way. Those words aren't real English words, they are symbols.

Okay, but what about error messages? A good error message tries to convey the nature of the error in a complete sentence or sentence fragment. Comments are often written in English. Documentation is often only available in English. Tooling suffers the same issue. Non English speakers are forced to learn English if they want mastery of the programming language, and this goes beyond mere symbol mappings.

> Okay, but what about error messages? A good error message tries to convey the nature of the error in a complete sentence or sentence fragment.

That's a fair point. I think I saw some compilers with translated error messages, which would solve that problem. But it was a long time ago, so I'm not sure. However, that is an issue external to the programming language per se.

> Comments are often written in English. Documentation is often only available in English.

When you get a programming book translated to Polish, comments are going to be written in Polish. Manpages have translations into many languages. As for library documentation, it's long past the point of an introductory programming course.

> Tooling suffers the same issue. Non English speakers are forced to learn English if they want mastery of the programming language, and this goes beyond mere symbol mappings.

True. However, I think it pays off big time. I think a world where people are forced to learn a language that everybody speaks is a much better world than one where different regions of the world have siloed repositories of knowledge, and collaboration can only happen on short distances. I think too often people complain that they need to learn A, in order to do B, even when A dramatically broadens their horizons and lifts the ceiling on what they can achieve. It's similar to the common antipathy towards being required to learn maths, if you want to do game engine programming, physics, etc. Without grasping a good chunk of maths, you're not going to be a good game engine developer or physicist. Same with English. Without it you're not going to be able to efficiently collaborate with others. Documentation is just one instance. There is also the usual asking questions on forums, reading blog posts, research papers. Those things may sound like restrictions to some, when in fact they're the opposite.

> I think I saw some compilers with translated error messages, which would solve that problem.

GCC has translated error messages and its horrible as it impossible to look up the errors onine and makes the errors useless when you seek support from someone who does not speak your language.

I made the same experience. The 'language' of a programming language is a red herring in any case. More of a burden is the relevant documentation and on-line resources, which overwhelmingly are in English.

I also find it frustrating, when comments or variable/function names are in anything but English. KDE, I look at you (even though I can read German just fine)!

Allowing anything but ASCII in a programming language is just inviting disaster. I'm not looking forward to find Chinese characters in source code ...

Perhaps we'll have some day an automated translation tool for source code, much like we have today for code-beutifiers.

Hmm .. while I agree there is a case for emojis :)

The ability to use Greek letters and Unicode symbols in Julia is delightful, because it helps the math in the code to look more like math, and makes the code in general more succinct. It’s optional, but seems to be popular. And Julia is not alone here, but the culture around it has embraced it.

On this note, Perl 6 (or Raku nowadays, I guess) takes IMO the best approach here (and if Julia doesn't already take this approach, it probably should): allowing both fancy Unicode symbols for those who prefer them and equivalent representations in ASCII (a.k.a. "Texas") for those who don't want to have to switch keyboard encodings or look up symbols to copy/paste or setup editor macros just to write code.

TeX commands are built in to the Julia REPL. Just type \alpha<TAB> and an α appears.

Re "(a.k.a. "Texas")", that meme has been removed from the documentation. It's now just ASCII vs Unicode: https://docs.raku.org/language/unicode_ascii

Lame. Ah well.

Haskell allows this as well. ASCII symbols are the default, while you can use the -XUnicodeSyntax language extension to get Unicode symbols. (My understanding is that Unicode characters are always allowed in identifiers.)

ASCII only source files should be considered legacy in my opinion.

I too prefer having function, variable and keywords in ascii as there is generally little to no ambiguity about what the character is or how it’s typed, but not being able to assign strings meaningful values in source code or add comments with meaningful and readable text for the domain of your program is an unnecessary burden.

you can already find plenty of chinese in code for ml papers.

Same here. E.g. I remember I had a problem with the proper understanding of AND and OR. But it wasn't because I didn't understand the words, it was because I didn't get the concept at first.

I pissed myself off quite a bit when my logical expression of something like "IF B<50 AND B>100" didn't work. Then my mother, who was also a programmer helped that I indeed needed an OR. I learned it, but it didn't make sense, because that's not what how I would have said it in (any!) natural language.

Later on I've figured out that my misunderstanding was caused by the fact that while I've written "IF B<50 AND B>100" I meant "IF B<50 AND IF B>100", or more precisely "WHEN B<50 AND WHEN B>100".

I also remember the surprise when learning that PEEK and POKE (two keywords in BASIC) actually both mean something and not just made up pair of words.

Latin-derived language speaker here (Portuguese). Also by studying other languages it turns out that English is quite good at expressing simple and composable symbols and structure.

While i would choose a latin-derived language to write poetry, speech or a novel because the expressivity, at least in those contexts are unparalleled, for clean, honest and even scientific terms, if there's a need for a human language, the english language, at least for me, is what suit those the best.

Apart from that its also a question of chance and historical events.. This sort of tool is great to teach younger kids to program and thinking in programming terms. But just like math, its reduced to a more symbolic level, so the word you are using to define things its not that relevant and giving that property, its a good thing that its more universal, just like in math.

As someone whose mother tongue is Spanish, and was born and raised in Latin America, this feels pointless at best, and counterproductive at worst. It will only add an extra layer of mental translation whenever someone who learned to program in this thing gets a real job.

I started learning BASIC when I was 3 or 4, way before I even understood English was a thing. If I could grasp what GOTO did, anyone can.

I remember having looked at BASIC code without any English or programming knowledge and having my attention caught by the GOTO statements since it was the most Spanish-looking word around.

> If I could grasp what GOTO did, anyone can.

Then I see no issue translating from this to an "english" programming language, so there would be no extra layer of mental translation.

I disagree (and if you want my credentials, I am Mexican). Being able to reason in your own language is a big help. I do this with mathematics in various ways. I can both easily say "sea equis una variable real tal que equis más ye son menor al límite de efe de equis más ye conforme ye tiende al infinito" or whatever in both English and Spanish, and sometimes I prefer saying it in Spanish and sometimes in English. I still count by default in Spanish, although of course I can count in English (or French or Russian). It feels to me like reasoning and language are close in the brain. While you and I have gotten used to thinking of for-loops instead of para-loops, I think there's good reason to think that a learner could benefit from reasoning in their own language.

As far as languages being useless, there's lots of other useless language a person could be learning. That doesn't discredit the raison d'être of these languages.

At least in the mind of an experienced code "for loops" have their own semantic existence, once you've understood them and given them a label then you don't need (in fact shouldn't) rely on intuition from your knowledge of English, or whatever natural language. Only one person I work with uses their computer in Spanish, whereas that's what everyone speaks all day, informally at least. I think of these words (programming keywords, names of Unix commands, etc.) as just symbols, doesn't everyone else?

(Of course this doesn't apply to learners, I don't know about that.)

I feel like I have to sound out things. It's important for me to be able to say "cp that over there" and I actually pronounce it as "copy" or say "ls" as "list".

I think a lot in words and about words. When I'm writing a for loop I usually sound out the whole thing, even if just mentally, "for ecks equals one to ten do" or "for whye in the range". I don't think I'm the only one who does this, so offering pronounceable things to other people in their own language might help.

Curious about your level of mathematics exposure? I remember that maybe in the most basic introduction to higher maths words were coupled with my reasoning, but later on reasoning was wordless (Jacques Hadamard reported something similar). Sometimes when I spend too much time doing math in the day, particularly doing proofs rather than reading, I have dreams about manipulating/deducting but no words or language for that matter is present. I've had similar experiences with programming and chess.

I majored in math and I mostly think with words.

I wonder if that’s your training. I do math for fun and don’t think in words. I often struggle to express my reasoning to others as a result.

I get this way with Beat Saber. I think I might have a problem.

It's not unusual, it's commonly called tetris effect

https://en.m.wikipedia.org/wiki/Tetris_effect

I did my bachelor's in maths in English and my master's in Spanish. I don't think my reasoning is very wordless, but I do think all of my reasoning is kind of geometric. I close my eyes and move my arms around to move a normaliser of a group action or try to trace with my fingers the integral lines of a manifold's tangent bundle.

But as I'm doing these things, I'm often muttering to myself as well, and I may do it in Spanish or English.

I get your point, and I admit I don't even know what language I think in anymore (if that's even a thing). But I'd argue that reasoning or talking about code is not the same as writing code. I went to university in Uruguay, so naturally when discussing stuff we'd say "son dos 'for' anidados" when a word didn't have a similar-sounding translation, or "escribir una función" when it did, and I'm fine with that. Discuss and reason in whatever you want.

But very early on I started writing identifiers and comments in English, and I think this is critical if you want your work to go anywhere. Say you write a piece of code and put it in Github, with Spanish identifiers and comments. You've just massively increased the barrier of entry to most collaborators in the world (have you ever come across code commented in Russian or Chinese? Not fun).

And this is just identifiers and comments, not keywords. I imagine using an entire programming language in anything but English can only make things worse :(

I agree with OP - the language seems to re-represent the languages key words in ways that are natural for Spanish speakers to understand.

I think the value this will bring isn't very high. I personally believe that early programming has less to do with reading the code as natural language and more to do with understanding what the individual constructs achieve. This is purely anecdotal, but I taught programming to a few students in French and the presence of English never came up as a blocker.

Fun story : for the hell of it, I once tried to code an entire project with some friends in French exclusively (that is, mainly variable/method/class names etc). As much as I love my mother tongue, its not always very concise. The whole thing became super bloated. We ended up reverting back to English.

Old pre-Internet Mexican here: when personal computers (think CoCos and Atari 800s) started coming, BASIC ruled, and it was extremely easy to grasp for kids:

GOSUB, RETURN, FOR, DIM, PRINT, PEEK, POKE, etc. were just abstract words that we just accepted without fully understanding their English roots. They might as well have been CALLBACK, THROW, ITER, FOO, BAR, etc., and we would have used them just as well. We reasoned in Spanish, then coded our reasoning in the abstraction that was BASIC. When reading code, it was like reading math, not a story.

More so, with the meme culture nowadays, even kids know enough English words to understand the roots of many tokens in programming languages.

Maybe programming with tokens rooted in your native language actually provides something I wasn't able to enjoy, but programming for me feels very different from speaking English, I'd bet the two don't even use the same brain regions, unless you're forcing yourself to comment in English.

Let's see what comes out of Latino. Hopefully they'll add Unicode identifiers later, because writing "funcion" instead of "función" is still bad Spanish.

The thing is that it isn't your language, even if you're native English. (I'm not, I'm Hungarian, which is a 100% weird language not too similar to any other.) Most programming languages, especially the ones used for introduction, use a very limited vocabulary. This e.g. pretty much looks like python, I'm sure it has no more that 40 keywords.

Most of your programs will not be keywords, i.e. symbols from the programming language, but the identifiers you define. Now you could use your native Spanish (or Russian or Hungarian, etc.) for those, but even that is not very useful. When you think about the program, you think with the constructs of the language (and also, as you get better, with the patterns you have learned). Then you express those thoughts with the language and the constructs you have created.

The only place I can imagine this making sense is a scratch-like block language. But I'd say that even then it just hinders learning and development. Sooner or later you'll have to switch and the later you do the harder it will be.

Also, this can be a great motivation to actually learn English. For me, at least, it was.

But not everyone who wants to learn how to program wants to program as a job. Moreover, proper localization goes well beyond changing keywords. Some languages are written right to left, or bottom to top. There's also tooling, debug messages, and and documentation. Why does all of this need to be in English? I think it's fine for people of other cultures to write tools localized to those cultures.

Debug and error messages in particular should NOT be translated unless an error code is displayed with them. Whenever I use anything that spits me a French error message, it becomes impossible to find out what it means using Google.

Windows error messages and the command line on Linux are particularly big offenders here.

It's a common theme in posts from ESL programmers that they learned English as they needed while learning to program. I can't help but think that removing that necessity would allow more people who don't speak English to learn to code. It's hard for me to see that as a bad thing.

It is? I've lived most my adult life in non-English-speaking countries and have seen the opposite—that programmers are less likely to be able to speak English well than people in less technical professions.

This is probably because many of them studied CS and spent comparatively more time with computers and less time consuming foreign language materials as students.

Logo programming language was translated into various natural languages (as AC Logo into Polish for example) and this was the only reason kids w/o foreign language skills (and English in particular) could wrap their heads around it and paint some cool stuff with the turtle, learning about recursion and what not at the same time.

I learned programming when I was five or six, way before I knew any foreign language, but my experience is no excuse for gatekeeping. Making programming accessible to a wider audience is unequivocally good.

Yes, I teach a Greek student who told me exactly this. His first introduction to programming was Greek Logo, and he attributes his entire trajectory to learning this one language.

For context, English isn't my first language -- but my Spanish fu is weak to say the least.

Many programming languages especially more terse, modern ones (I'm looking at you, Rust) -- the symbols don't mean anything in English either. Does "for" or "fn" or "impl" mean anything to average English speakers? This feels more like a bunch of extra symbols like "==" and "!" rather than the anglosphere enforcing its dominance.

There's plenty of room in the programming languages space for this one, to be sure -- I've nothing against it. It almost feels like ergonomics and writability are reduced in this language to make it more like Spanish than a modern functional programming language is like English. It almost goes out of its way to replace symbols with words. More like a Spanish AppleScript.

Feels more like it's making a point than solving a problem, but I'd love to get more perspective from Spanish speakers.

I wonder how much confusion in learning there for English speakers because of the use of English words. I might be a better programmer if I had been forced to learn abstractions in a different way.

In math, if I see an unfamiliar symbol I immediately know I don’t know what it means. If it were English instead I’d automatically try to fill in a meaning. (Of course there is also a problem of overloaded symbols...)

> Many programming languages especially more terse, modern ones (I'm looking at you, Rust) -- the symbols don't mean anything in English either. Does "for" or "fn" or "impl" mean anything to average English speakers? This feels more like a bunch of extra symbols like "==" and "!" rather than the anglosphere enforcing its dominance.

Yes, they do. When I was learning Rust it was obvious that "fn" was function. "impl" is a little trickier, but I read it as "implements" or "implementation of". "dyn" is "dynamic implementation of" or something like that. And "for" is the same in all the other programming languages I know.

I was suggesting that while you and I may know what they mean, the average person unfamiliar with programming is definitely going to be thrown for a loop, if you will.

I'm with you, but I went the other direction: native English speaker who learned French localized BASIC (correction: LOGO[0]) in a summer program. The words map pretty quickly to the abstract concepts without any real need for a translation step. I did that as a kid, but I don't see any problem learning a programming language in a different language as an adult.

Realistically, what's far more important than the language of the keywords is the language of the rest of the identifiers. I've typed a lot more distinct function and variable names than keywords.

[0] Jogged my memory: https://news.ycombinator.com/item?id=26809211

> Realistically, what's far more important than the language of the keywords is the language of the rest of the identifiers.

Exactly. Or the doc.

Having a standard library with a localized doc would probably help out learners way more than localizing some keywords. As one gets further and further away from the standard library, the doc increasingly won't be localized but by then the reader should know enough "engineering English" to get by.

It also reduces the surface area of collaboration, sharing, open sourcing, security audits, etc. We have standardized in English and it is as arbitrary as any other language - English just happens to be the one chosen.

This whole thing needs to be condemned, we get it - its fun to do something about your local language and be proud of your culture - everyone is. You should be. But, trying to peddle this into mainstream is a monumentally catastrophic. I don't want the world to be fragmented - we need to get together and build better tools.

If anyone who has worked on Chinese datasheets, oh boy, you know the pain.

I think it's not fair to require everyone to know English enough to be able to write comments in code.

Do you think its fair to require everyone to follow any standard?

Think of English not in the context of cultural importance/language but more formally as a de facto standard. A professional would follow the standards. This is why we have IETF. It is unquestionable and indisputable that standardization improves the world.

That said, comments are probably fine in local language.

Actually, this used to be the norm, back in the day. The Algol 68 standard, for example, is language-independent, i.e. it admits representation of code in any natural language.

Not a native English speaker either, and I prefer languages the way they are, but - I don't think of them as English per se. BASIC or C or Java could have "blargh" loops for all I care as long as I internalize them they work fine. I guess you could easily accomplish that in C, heh.

Cool to see programming languages using non-english as a base.

However,

> No son validas las letras acentuadas u otros caracteres como la ñ.

["Accented letters or other characters such as ñ are not valid." sez deepl]

https://manual.lenguajelatino.org/es/stable/sintaxis/Variabl...

Looks like it doesn't support accented characters in variable names. I wonder what their reason for excluding those is?

I know that languages like Swift can support Emoji, so why not support accented latin characters?

Full Emoji support is ... horrendous ... I look into it about once a year; I think there are proposals for unicode but as of now it's still super hard to detect if something's a single emoji symbol or not (the most current regex I saw for emoji-matching was, IIRC, several KB in size...). Some day in our cyberpunk future we'll get there...probably some decades after full self-driving vehicles have become standard...

Lack of Unicode support in the parser? Can't think of any other reason.

I'm guessing it's because the language was implemented in C, whose stdlib doesn't really do Unicode strings, and the authors didn't think to use a different string type for identifiers until it was too late.

You don't need "Unicode strings" for this - and C strings can hold UTF-8 just fine. What you need is Unicode-normalization so that different ways to compose the same character refer to the same variable, but that can be done in C with a library just fine.

Non-English-based programming was common in the Soviet Union, but certainly not unique to it:

https://en.wikipedia.org/wiki/Non-English-based_programming_...

It does seem like support for Spanish-language characters should be a feature of a Spanish-based programming language.

I don't know what was they reason they chose but a one possible one is that unicode variable names introduce several implementation challenges. You need to worry about normalization (the same character may be represented by different byte sequences) and you might need to have large tables to be able to tell whether an unicode character is a letter or a symbol. There are also problems with encodings; UTF-8 vs Latin-1 and so on...

I imagine it wouldn't have been that hard, if the authors had just used ICU4C for string handling. I've had good luck with just converting all input to normal form C. The bigger challenge there is that, if you're using ICU strings, then you've lost the ability to use any library that is designed to work with C strings. There's no way to avoid 0x00 showing up in the middle of UTF-16 and UTF-32 strings, and, even if you use modified UTF-8 to avoid NUL bytes, you still break the assumption that a string's length is equal to its size is bytes.

Not to mention the inherent problem of adding a dependency to an external library.

I know that in the case of Lua that was one of the main reasons. ICU by itself would be larger than the rest of the interpreter.

Yeah, I wonder the same. After all making a programming language derived from a real language and not using the "features" of said language seems lacking.

In fact it should be "función", that way it would not matter whether you are writing code or documentation.

Here's the Sieve of Eratosthenes as a fun example of what you're asking for[1].

        #! /usr/local/bin/perl -w
        use Lingua::Romana::Perligata;
        maximum inquementum tum biguttam egresso scribe.
        meo maximo vestibulo perlegamentum da.
        da duo tum maximum conscribementa meis listis.
        dum listis decapitamentum damentum nexto
            fac sic
                nextum tum novumversum scribe egresso.
                lista sic hoc recidementum nextum cis vannementa da listis.
            cis.

[1] http://users.monash.edu/~damian/papers/HTML/Perligata.html

Oh now that I've learned some Latin I can understand this page a lot better. Thanks for the reminder it exists!

We really need an ñ operator

Great, now everybody will laugh when you try to name a variable “year”.

I spent way too long trying to work out if there was an accented Spanish word "yéar" or something that was funny...

For those who don't speak Spanish, año is "year", and without the accent on the "ñ", it's a body part that you can probably guess :)

that's why I type it `anho` when speaking with latino friends i don't have the n on my english keyboard

        setxkbmap us -variant intl -option compose:rwin]

Press altgr or right win key + [aeiou] or n.

You're using the Portuguese transliteration of the eñe. And if you were doing it with an Italian or French transliteration, you could write "agno."

(That said, it's one that's so common it's worth learning the keyboard shortcut for. On a Mac it's "opt-n, n".)

As a native Spanish speaker, this doesn’t make sense to me.

Even if the argument of lowering the entry bar to non-English speakers was valid (I don’t think it is) the individual would be severely limited when it comes to collaborating/GitHub/external libraries/learning new programming languages.

A big advantage of learning a programming language is that once you understand what a “loop” or a “if” you can easily transfer that knowledge to another language.

Learning this language as your first language will leave you with very little transferable knowledge without much “translation” needed (pun intended)

I've commented on this before, but I think the issue is programming languages mix presentation with representation, i.e. text is used for both. Aside from making tooling more difficult it also prevents a programming language from being multilingual.

While I agree simple keywords in a programming language aren't that big of a deal to learn as they are essentially symbols; things get a lot more complicated in a real project if a contributor is not a native speaker. Identifiers and comments - which are used for source code documentation - are in a single language and can't be translated easily.

If the presentation and representation were split such that the presentation (still text mind you) is just a rendering of the representation then it could go through a translation process in the same way web pages do. Of course there would be an added project overhead of maintaining translations so maybe it wouldn't be worth it.

This might be somewhat of a moot point as English is quickly becoming the lingua franca. Things such as issue tracking also require some common language outside of the source code itself.

The `unison` programming language represents all symbols as labels on hashes, so it makes it relatively trivial to remap from one language to another.

I commented on another thread about being hype about this, and people pushed back, commenting that it's really beneficial to have English as the lingua franca of software development.

It strikes me that lowering the barrier to entry by not forcing someone to learn programming and English is positive. But fragmenting standard communication language harms software as a whole. Plus, learn English and you get access to millions upon millions of man hours in libraries and documentation.

Maybe it's not really an either/or here; better for people to have choices.

All of that said, "Latino" seems like a particularly terrible name for a programming language: it should probably be hispanohablantes for correctness.

> All of that said, "Latino" seems like a particularly terrible name for a programming language

Now I'm not sure who you think python is for...

I think Python is a good name because although it's arbitrary, there's very little domain overlap that could cause confusion: context can pretty much always tell you whether people are referring to the language or the animal.

Latino, on the other hand, seems to have a little more overlap: it's very close to Latin, an actual language, and also refers to the latinoamericano cultural identity, which is largely defined in relation to language. Thus the possibilities for confusion seem a bit greater (I think OP's suggestion of "hispanohablantes" would also cause a lot of confusion).

Yes, hispanohablantes was a little tongue in cheek. Perhaps latinx for maximal confusion

Presumably latinx will be an X Windows implementation in Latino. At least I hope that happens at some point because I enjoy punny approaches to naming things.

> Perhaps latinx for maximal confusion

Latin@ is a little bit less of an USAism, but I'm not sure if that's a pro or con in the maximal confusion department.

that just means you need regionalization. Latin@ for americans, latinx for everyone else.

As a non-English speaker, I don't really conceptualize code as English. Tokens being 'if', 'while', 'else' is completely trivial, like using '{' instead of 'begin' or '[]<class T>(T i) {return i;};' instead of '(lambda (x) x)' or 'y => y'.

I wrote my first line of code before I wrote my first word in English, the status-quo doesn't really require you to learn English beyond a couple trivial tokens.

I agree choices are good and I hope the project succeeds, but it must be stressed that learning English isn't really optional anyway, it's a hard requirement for any IT-related job worldwide.

I think it might affect some languages more than others - perl is just line noise in any language, but I could see SQL "dialects" in various languages.

But even then I feel that in that case non-english speakers might have a bit of an advantage as they don't assume things about SQL because it doesn't look like their native language.

> but I could see SQL "dialects" in various languages.

IIRC AppleScript used to support French, but it's an unpopular variant of an unpopular language, so I'm not really sure how many people actually used it.

> But even then I feel that in that case non-english speakers might have a bit of an advantage as they don't assume things about SQL because it doesn't look like their native language.

Yeah, the sooner you realize it's the abstract and not the concrete syntax you're actually manipulating, the better. IME (natural) language is just not a barrier at all.

That's true for keywords, but a much bigger problem are standard libraries. I don't think you could realistically understand the Swing API to pick an example without understanding English, even if you had access to docs in another language.

Documentation too.

> It strikes me that lowering the barrier to entry by not forcing someone to learn programming and English is positive.

In my country's technology courses, students are often introduced to programming through a language called Portugol which is essentially a translated Pascal. There's no compiler, no interpreter or anything. For months on end students have to write procedural code on paper with this useless language.

Wow, that sucks. Wouldn't a source-to-source compiler into Pascal be a good option in that case? Writing a simple compilers might also be a good learning opportunity for the more experienced. Compilers are a way simpler concept than they might seem and really easy to write too.

There is a bunch of portugol compilers, all incompatible with each other since this is not a well defined language. Kinda the point is to not waste time learning syntax and use whatever imaginary functions calls you want.

The more serious problem is when teachers uses it as a hammer to every nail and teach advanced concepts using it, so students are forced to reason about fine syntax of a fictional language.

I would think that if there is any language that could be a viable alternative to English for programming, it would be Chinese: more native speakers than any other language, and with a writing system distant enough from that of English that learning English might actually constitute a significant barrier. Spanish is just not there. Yes, there are a lot of native speakers, but it's close enough to English that it's probably not going to be worthwhile to most Spanish-speaking programmers to participate in the alternative ecosystem (not to mention that it has less economic clout than Chinese).

Great. Now programming languages are also political tools. We should do the same in science. Every scientist should learn every language of every other scientist so everybody can write their papers in the language of the culture they identify with. That will surely advance science and benefit all of us immensely.

I'm confused what this has to do with politics.

Apparently there are two languages: English and political.

Latino isn't a language, it's an identity. That makes it political.

Really it's a geographic location of origin.

There's nothing particularly political about being from South america

As someone who is latin american, I never understood what is the obsession with identity in the US. American hispanics I've talked to use it as something of a catch-all concept, but I've observed that many only have a meagre proficiency in Spanish and know nothing about the other Latin American countries that they pack with the bunch (apart from their own/their parents).

This is a touchy subject in the US so I don't want to get too into it, its a bit off topic. The shortest and most neutral answer I can give is that minority political groups in the US use identity as a tool to push for political change.

Historically, a large part of it goes back to the Treaty of Hildalgo.

It obligated the US to enfranchise Mexican citizens living in the seceded lands of Alta California.

This immediately threw a wrench in antebellum politics which only allowed "white people" the vote. Eventually the US invented a racial category based on speaking Spanish...well actually two, one black, one non-black.

Fundamentally the identity of people with cultural affiliation to Spanish speaking cultures is complicated by the sanctioned narratives of US history which do not allow for the US to consider its Latin American heritage.

You could sleep in a hotel in Santa Fe and eat in a restaurant when the Pilgrims came ashore at Plymouth Rock. And when "fulfilled manifest destiny" reached the California coast, there were churches there where people went on Sunday...and chattel slavery had been banned for two hundred years.

To me the most non-sensical part in this kind of arguments is that most of the people identifying themselves as “Latino” are people from the US. Most people actually born in latin america will self-identify with their country of origin (Argentinian, Colombian,..)

The advantage native English speakers have in terms of leading CS projects, making start ups, and getting the high paying tech jobs lessens if speaking English isn't a major requirement for reading and writing code.

If instead you need to know Spanish, or don't need to know any one specific langauge, it challenges or changes the power structure and is thus political.

People getting defensive in this thread over the idea of a language not made for them is great evidence of this. Instead of ignoring it like the millions of new projects that don’t apply to you, we must go out of our way to explain why this is bad and wrong.

You're right. Imagine if other countries had science journals in their own languages.

Science would collapse and politics would reign supreme.

You do know that pre ww2 if you worked in chemistry (and physics to an extent) you basically had to learn German, so you could read the papers.

It happened to be the lingua franca for the field at the time. So?

And the lingua franca for programming is English so what

That it is. Your point is?

This isn't the first language to do this. This isn't even the first post about this.

https://hn.algolia.com/?q=non%2Denglish%20programming%20lang...

We could do the same with units, so Americans could talk in freedom inches while the French talk in metres

Oh come on. Given that

* there's already an immense body of scientific work written in languages like Chinese and French that the English-speaking world lacks access to,

* the main goal of this language is clearly not for international collaboration or anything like that,

* not everything non-English is "political", and

* sometimes people just want to teach kids programming without having to teach them words in an unfamilar language, too,

your comment comes across as thoroughly nonsensical.

The lingua-franca of EU is EuroEnglish, for obvious reasons: https://en.wikipedia.org/wiki/Euro_English

How does this rebut any of the points you are replying to?

To all native English speakers, before talking about standards and lingua franca, try to implement some basic algorithms in Latino and take a minute to imagine a world where it is the standard (programming & documentation). Then you'll understand the meaning of "entry barrier" and "language advantage", if you remember that's the reality for billions of people in the world including me.

Thank you. Too many commenters here, years removed from being a beginner, aren't getting it.

As someone who doesn't care about the language, my question is if the goal is to reduce the entry barrier, what is the benefit of this language versus investing the same amount of time in Spanish documentation and a Spanish transpiler for Python? Multi language documentation is definitely lacking, but making a new language adds to the complexity of the space, it doesn't reduce it.

Multi-lingual documentation is premised on the idea that languages derived from English are better or at least good enough. The premise of this language is that they are not.

The Python community is not committed to multi-language documentation. And it has the ideology of "unpythonic" as an excuse for denigrating anyone who might be.

I hardly call the use of a few keywords as "derived from English". There are 36 keywords in Python, one of them being __peg_parser__, what the hell does that mean for an English speaker? Maybe the Python community is not the best example, I did not know they actively subverted any attempts at multi-language. But still, forking the project and simply renaming and translating the documentation would serve much better at lowering the barrier of entry, if that's the goal. The cynic in me thinks that the creators of the language simply used that excuse as a way to justify scratching their itch to create a new language given that there are so many better ways to remove the English barrier to programming.

Python was mentioned in the parent comment.

“List comprehension” is English. “Object” is English. “Keywords” too. As well as “benevolent dictator for life.”

Python doesn’t embrace non-English efforts. That’s the nature of it as a community...not encouraging second ways of doing things is its dogma.

> Python was mentioned in the parent comment.

Yes, you're still talking to the same person. But your comment is even more confusing. Are you arguing that "list comprehensions" are part of the language because we have a nice pairing of English words for that thing and that core programming concepts are missing because we don't have English words for them? It seems like an absurd stance, especially because we're talking about Spanish where it's basically a meme to add "a" or "o" to the end of the English word. Almost all programming concepts are words that I'd never use in daily conversation. Again, my root argument is that if you want to serve the Spanish community, forking the <any established language> project and translating everything seems like more payoff for less effort than creating a brand new language. It doesn't really matter what the original community thinks.

As an educator, specifically to South Americans learning programming and data science, the biggest hurdle I encounter is understanding concepts not that the words are in English. Logistic regression, L1 regularization, OLS, for loop, Simpson's paradox, none of the hard parts in teaching those are the fact they contain English words.

To begin with, the page is full of typos and grammar errors. Many parts of it read like they were translated by beginners in Spanish or machine translation (so kind of , what’s the point if they’re using Spanish carelessly?).

Then, a bunch of the keywords in the programming language itself don’t make a lot of sense - “for” maps to “desde”, not “para” - so I have to remember an arbitrary term that doesn’t do what it means or mean what it does. At that point I might as well learn “for”, right?

Remembering that “si” is “if” doesn’t seem like a huge burden. The fact that “si” in Spanish is used as both a conditional and affirmative (“yes”) can actually lead to more confusion and ambiguity.

Overall it doesn’t feel like a very well-designed language nor does it feel natural as a Spanish speaker which defeats the point.

Es una locura esto, el siguiente paso es hacer una version para el dialecto de cada país: en Colombia el "While" se deberia llamar "peroporquehomeeee" o "sisas" !

"para cada ... tal cual" que pesada ;)

Y en el lado ibérico, si ponemos el murciano o extremeño igual invocamos a Cthulu con cada excepción.

var queMasPues = bien || que

I still remember Visual Basic with Spanish keywords. It was... a mess, and it really didn't do anything for Spanish speakers except fragment the VB user base.

Also with VBA for MSOffice where even damn Excel functions were localized. Useless crap.

Regarding the WHY question...

> El desarrollo y administración del lenguaje Latino para que escuelas, universidades, maestros, estudiantes y profesionales encuentre en Latino una herramienta para resolver los problemas del día a día.

The development and administration of the Latino language so that schools, universities, teachers, students, and professionals find a tool to solve day to day problems.

It seems to be targeting teaching and learning as well as some simple business use. Interesting idea, I wonder if it will catch on.

Back before I progressed beyond DOS batchfiles, I kind of just assumed that all the commands and keywords would be localized to whatever the local language was - I didn't think, for example, that Japanese-speaking users were out there typing "echo" and "dir" and "printf". I found it surprising and seemingly unjust when I learned that folks that spoke other languages generally had to learn a fair bit of English along whatever programming language they were learning. I can't imagine how much harder it must be to pick something up when the mnemonics are foreign gibberish to you. Of course now I realize that there's an element of practicality to it as well; J. Random Hacker can hardly be expected to translate the API they created into N different languages that they don't speak themselves. It also cuts both ways; GitHub Trending is increasingly full of projects that look like they're probably awesome and extremely useful and I have no idea what they even are because the documentation is entirely in Chinese.

I know some early versions of BASIC would save your source in a "tokenized" format, i.e. instead of literally storing "PRINT $FOO" they would store some bytecode that represented PRINT instead. One could possibly implement a polyglot programming language using a similar mechanism, and translate localized versions of keywords into (human) language-independent bytecodes. You'd have to pick one human language to be the canonical representation though, or have some sort of language declaration at the beginning of the file, or commit to having the canonical representation of your source code not be plain text - all of which seem suboptimal for different reasons. It also seems like it would be tough to extend that approach to code outside the standard library of the theoretical polyglot language.

I really don't think this is as bad as people make it out to be. As you said, it's totally possible -- actually fairly straightforward -- to build a programming language with keywords that can be in various languages. Perl has a package that uses Latin constructs instead of English.

So if there were a huge demand for this kind of thing, we'd probably see a lot of it.

There are other professions which require the use of foreign terminology: lawyers use Latin, doctors use Greek & Latin, chefs use French. Sure, it makes things a little difficult at first, but it's probably not any more difficult than learning technical jargon in you native tongue. In fact, in some ways, it might be easier because the literal translation of "echo" might not actually make much sense to a Japanese speaker in the context of programming, whereas, with English you can teach a Japanese student that "echo" means to put characters on the screen.

I remember reading about an effort Britain had to make the law more "accessible" by using English instead of Latin, and it just made things more difficult because instead of seeing words you had no idea the meaning of, now one knew what the statement said, but it would mean something completely different than they would expect.

> One could possibly implement a polyglot programming language using a similar mechanism, and translate localized versions of keywords into (human) language-independent bytecodes.

I'm stretching it here, but assembly would tick all boxes here.

There are certain obvious advantages to using a single language.

For example: I read r/IWantOut, as well as some CS career-related subs, and I myself am an American coder in Germany. Based on my own experience, as well as my reading and hearing from others, programming is probably the best overall career choice if you want the option of living in various different countries, in terms of how accessible it is as well as having decent pay. A big part of that accessibility is English, that you can find a significant number of jobs in many countries that don't require you to already know the local language.

I recall that VBA in Office 4.2 or thereabouts supported localized versions of Visual Basic.

Excel also supports localized formulas and cell references.

HyperCard also supported localized versions of HyperTalk, but I think only a French sample localization was ever provided.

Cool! It looks very similar to a language we designed and implemented for a uni assignment years ago, using flex and bison:

  principal
    inicio
      entero x, y;

      leer (x);
      leer (y);

      si (x > 0) entonces
        si (y > 0) entonces
          imprimir (1);
        is

        si (y == 0) entonces
          imprimir (0);
        is
 
        si (y < 0) entonces
          imprimir (2);
        is
      is
      si (x == 0) entonces
        imprimir (0);
      is
      si (x < 0) entonces
        si (y > 0) entonces
          imprimir (4);
        is
        si (y == 0) entonces
          imprimir (0);
        is
        si (y < 0) entonces
          imprimir (3);
        is
      is
    fin

la unica pregunta que tengo es .... porque? Nosotros que somos hispanohablantes no hemos necesitado esto - los lenguajes que ya existen sirven muy bien.

Como un ejercisio tecnico, les aplaudo. Pero no es un `Lisp`, y asi, no es para mi

It looks more or less like Javascript with Spanish keywords instead of English. I guess it's an argument for a purely symbolic (and therefore equally accessible) programming language.

That's an interesting point - on the topic of readability, its often argued that the more abstract symbols and operators used, the harder it is to read (I think this is why operator overloading is sometimes frowned upon). But if you are not fluent in English, it wouldn't be much more accessible than a purely symbolic language.

The tricky thing about this, is we search based on language all the time. It's harder to search for an operator if you don't already know what that operator is called.

Maybe you could build this into the tooling of the symbolic language? E.g. provide a semantic name for a given std lib function in your chosen language, and get intellisense in your language.

Symbols have different meanings in language too. For example, would you use "string" or «string» to quote a string?

Porque se puede.

Pienso que también tiene mucho valor como herramienta de educación más que para usarse en la industria.

Hola, saludos y gracias por tu comentario.

Tienes razon que hay aplicación en el sistema de educación. Pero mi respuesta es esta: no sería mas eficiente hacer un tutorial de las palabras ingleses, y luego usar nombres españoles para las variables y funciones?

I have a feeling that English keywords mixed with Spanish words for names of things would look like a mess.

De acuerdo... me parece una pérdida de tiempo y/o una idea terrible.

como ejercicio parece muy interesante pero para algún uso real o educativo creo que no es la mejor opción.

Fuera de tema: He leido HN los últimos tres años y creo que es el primer comentario en español que he visto. Solo dato curioso.

Depende de cuáles hispanohablantes estemos hablando. Cierto es que muchos de nosotros simplemente hemos aceptado que la programación, por lo menos las palabras clave, estarán en inglés. Pero los novatos y aprendices que nunca han programado y que no hablan inglés, quizás podrían aprender mejor con un lenguaje en su idioma.

No debería ser requisito riguroso hablar inglés para poder participar en la creación de software. Y no lo es, en general, salvo por algunas palabras clave en lenguajes de programación. Si es posible reducir esta barrera... ¿por qué no?

La gente habla de que esto fragmentará más a la comunidad. Fragmentados ya estamos. Hay mucha gente que no puede entender con facilidad las respuestas en Stack Overflow. Si fomentamos y propiciamos más el uso de otros idiomas, seguramente podríamos acercarnos más a mucha más gente que podría ser nuestros futuros colaboradores.

Hola, y saludos!

> Pero los novatos y aprendices que nunca han programado y que no hablan inglés, quizás podrían aprender mejor con un lenguaje en su idioma.

Es mi opiñon que el pueblo (hispanohablante) que esten aprendiendo la programacion traslape mucho con el pueblo que por lo menos conoce un poco de ingles. Asi, las palabras comunes como `print`, `if`, y `return` son muy faciles aprender.

Yo estoy de acuerdo con tus comentarios sobre la fragmentacion; el problema que tengo yo con este idea de lenguajes de programacion en otras lenguas es que el vocabulario no es interoperable. Si una persona empieza aqui, está empezando con una desventaja. Está condenada a usar esta lenguaje - que quizás no sirve para la aplicacion deseada.

Con todo esto, quiero decir que es una victoria cada novato que empieze aprender la programacion. Solo que el lenguaje en español puede ser una trampa - ya dijiste tú en cómo: por ejemplo, no se puede comunicar en StackOverflow para buscar ayuda.

Mucho gusto comunicarme contigo, el español es una de mis lenguas pero no es la primaria. Saludos

Francamente, la principal barrera que he visto no es que los lenguajes de programación estén en inglés sino que la gran mayoría de artículos técnicos, libros, foros (HN), etc., lo están.

Para reducir esta barrera la mejor y más fácil solución es aprender inglés. En la programación normalmente hay que aprender muchos lenguajes, diría que aprender otro idioma (lenguaje natural) no es tan diferente y el haber tenido que hacerlo nos hace mejores programadores.

Por otro lado, no creo que esté mal aprender a programar usando lenguajes que luego no vayas a usar; así que si Latino sí facilita el aprendizaje para hispanohablantes, en comparación a otros lenguajes usados en la educación (Java, Python, JS), pero que están en inglés, diría que no es un mal proyecto.

Pero si por mí fuera, hubiera preferido aprender a programar, no con un lenguaje en español, sino con un Lisp (Scheme o Racket).

Dime, ¿podrías con facilidad memorizar unas 20-30 palabras claves en chino o en ruso? ¿Crees que esto impediría el uso de un lenguaje de programación?

No es comparable, el alfabeto inglés es un subconjunto del castellano.

También me preguntaba esto cuando escribía mi mensaje previo, pero no lo mencioné porque el chino usa caracteres no latinos. En el caso de palabras claves en inglés, aunque no sepa pronunciarlas les puedo asignar un sonido en mi mente, lo que ayuda a memorizar; en el caso del chino, estaría en chino… :P

Hace rato estaba leyendo sobre https://en.wikipedia.org/wiki/William_Tyndale y su traducción de la Biblia del latín al inglés. Supongo que en ese caso, fue más fácil (digo fácil, pero spoiler alert lo mataron) traducir la Biblia que hacer que toda la población inglesa aprendiera latín. Lo menciono porque pensé: «he aquí un caso en el que traducir fue la mejor opción». Y eso que ambos idiomas tienen el mismo alfabeto.

Supongo que sí puede ser una barrera, hasta cierto punto, que las palabras clave no estén en tu lengua natal, pero un mayor problema es que los recursos de aprendizaje suelen ser ininteligibles si no sabes —y a veces aun sabiendo— inglés.

Leyendo el resto de los comentarios, sigo sin entender porqué habría de ser más difícil aprender de una manera u otra. Estoy de acuerdo con la idea de que sea estándar. En el peor de los casos (si fuera cierto que es más difícil), los empleadores en LA (Latino América) lo tendrían en cuenta, pero a nadie le importa. Eso refuta toda la argumentación.

Why is it called "Latino" when it is just in Spanish and not Portuguese (or maybe French? not sure if Haitians are Latino). It seems like "Hispanic" would be the better term since this is language focused rather than geography focused.

"Latino" is kind of a cultural designation of the US to refer to Spanish speakers, although it is used somewhat outside of the US, but not as prominently. I am guessing this language was just being made in the US where Latino is an accepted descriptor for Spanish speakers only.

It very commonly refers to Portuguese-speaking Brazilians in my area.

The big problem of this use for me is that people from the US tend to think in terms of "race". Like if there is a homogeneous "latino race" where it boils down to the average mexican immigrant that the US is more used to.

For instance, you can see this in north-american films, where the mexicans are hired to play Brazilians, where we (brazilians) can spot right-away they dont look like any type of average looking brazilian. But im pretty sure it make sense for the crew of the film and people watching it, even when they speak spanish.

Just to give you a glimpse of famous brazilians north-americans may know: Rodrigo Santoro, Morena Bacarin, Alice Braga, Gisele Bundchen, Alessandra Ambrosio, Jordana Brewster, Camilla Belle, Kaya Scodelario, Wagner Moura.

The thing is, i've just give you this sample, so you can see how they don't have any resemblance between each other or homogeneous look. The ones that speak perfect english can perfectly act in roles not meant for "latinos" and nobody notice it.

I think nowadays is right to use this term in the same sense as you use for Europe to define France or Italy as part of Europe. Albeit is even wrong to use in the sense of a continent giving America is just one continent, with north and south.

Anyway if you dig down and look to all the inconsistencies of the term it boils down to some sort of racial profiling thing, because it makes no sense in any other way you look at it except for labeling it as "not white".

Yeap, it's a very inconsistent mess up here. In the media, "Latino" and "Hispanic" are often treated interchangeably, and both as though they were a race. It's very common to see statistics broken down like "White, Black, Hispanic". This confusion reaches even the highest levels, including people who really should know better, e.g. see this "apology" which somehow still doesn't seem to understand that "Latino" is not a race: https://www.npr.org/2020/08/07/900147716/

> Albeit is even wrong to use in the sense of a continent giving America is just one continent, with north and south.

To make matters even worse, we're taught in school is that North America is a distinct continent by itself, as is South America, and that there is no continent named "America". This leads some North American "patriots" to get upset at the idea of a single continent, hence the insistence that the word "America" and "Americans" only refer to the USA.

I'm not an expert in USA culture, but looking from a distance it looks to me that this is cartesianism (as in pattern-matching) applied to social sciences, which as it turns out, is a legacy of the 19th century which lead to it's most extremist version represented in fascism.

I say this because here we have this too, as in any other part in the world, the only difference is that the targets are others.

Remember the obsession of those folks to measure and document people turning this into some sort of science where you could classify people objectively giving some properties drawing hard lines that would not be crossed. Once they defined what was the superior type it would be a matter of marginalize and eliminate the weaker to achieve the super race.

We all still do this here and there, but is much more organic, subtle and disguised as something else.

Anyway is funny to think that in US (and Brazil), the last wave of immigrants arriving were considered the low people and only with subsequent waves of immigrants the old "dirty ones" got some sort of social upgrade.

As irish in the US were marginalized and later the jews, polish and italians replace them as people with less value.

Here for instance, japaneses and italians were treated pretty badly in the beginning of the 20th century. (It was even worse for black people).

Its funny to see how people don't learn with history. There's no nobility by birth, at most it was the parents passing education and culture to their children. Leave a human alone in the forest and if he manage to survive it will behave like an animal.

Hahah yeap we're basically back to skull-size measuring. And what you write is exactly correct: It's a definitely form of "othering", arbitrarily separating people.

I've lived in both countries (US and Brazil) and another comparison I've heard made is between internal immigrants in Brazil such as from the Northeast, and Hispanic immigrants in the US (some internal, some external). A lot of it is economic. As an example, very similar economic & climate pressures that caused Northeasterners of Brazil to journey to SP, RJ, etc, caused many farmers in the dry lands of northern Mexico to move north (and seek jobs in the US as nannies & housekeepers, construction, large farms with horrible labor practices, etc).

One huge difference is language. I know many Brazilians I've chatted with were surprised to learn that ~15% of the US speaks Spanish. The US is very much a linguistically-segregated country, as much of it was once ruled by the Spanish Empire or successor states, and thus regions of it have never traditionally spoken English (and still don't). Puerto Rico of course is entirely Spanish-speaking and always has been, and areas of different states are majority Spanish-speaking, and most cities in the US have at least one or two neighborhoods that are primarily Spanish.

Using "latino" to refer to Spanish speakers is a doubly offensive act of US-ian cultural imperialism.

First, "latin" generally means romance language, i.e., languages descended from latin, including French, Italian, Romanian, Portuguese, Catalan, and so on. Using this word to refer exclusively to Spanish makes sense only from the point of view of the USA, where the largest group of latin people are Spanish speakers. Thus, imposing this usage in an international context reeks of U.S. cultural imperialism.

Second, "latin america" was originally defined by the French in opposition to "anglo america", to designate specifically Québec, part of Louisiana, Mexico, etc; the areas of the Americas where latin languages are spoken. This excludes large swaths of the americas in Bolivia, Peru, Brasil, Mexico, where other languages are spoken (Guarani, Aymara, etc).

I consider latin or latino myself, but I wouldn't touch this US-assumption-infested "Latino Programming Language" with a ten foot pole.

To be fair, it is not (never mind the HN post title) “The Latino Programming Language”, it is “Latino, Lenguaje de programación“.

The French Ministry of National Education tried supporting a similar sort of effort 50 years ago: https://en.wikipedia.org/wiki/LSE_(programming_language)

Instead of entire new programming languages, maybe existing languages can have alternate localizations (done at the IDE level). The same source code would display in a different language from a user with their IDE in Spanish vs the user with their IDE in English.

Edit: Food for thought regarding reserved keywords...

Not sure what the fuss is about. Plenty of languages[0] have existed that used native keywords over English. Unless your natural language's grammar introduces some novel syntactic or semantic features to the programming language, this is superficial. It's just a kind of localization. You could adapt the parser for any language to do this. Heck, in a Lisp, you can just define a bunch of aliases and wrappers and load that into your current namespace if you want.

[0] https://en.wikipedia.org/wiki/Non-English-based_programming_...

I know they are aiming to be a real language but isn't this effectively an art project? In that sense, it is very effective at pointing out how English-centric programming is. As a non Spanish speaker, I instantly felt what those learning to program must feel when they don't know any English. Utter confusion.

It does seem like it should be trivial for every programming language to have a localization file for keywords to be rendered in a local version on the user's machine. Though then you still have to deal with variables and comments.

Most things in programming are human conventions that you have to learn. There is rarely a way to guess or figure things out. Keywords, scoping, byte order... It's all arbitrary, understanding the English meaning of the world "yield" in English will do little to help you understand generators.

No, the real problem is the reading material. If you need to debug/read doc/google stuff, anything worth something (except a few exceptions like samemax.com and so on) will be in English.

I've seen French professionals being perfectly capable programmers, but because their English sucked, their struggled to solve some problems that were a Stackoverflow post away.

EPL (Easy Programming Language, EYuYan, 易语言) is a Chinese programming language.

https://en.wikipedia.org/wiki/Easy_Programming_Language is a terse page explaining it but I guess any actual document would be in Chinese.

From my understanding this language is very popular in amount people writing game cheating tools and other malware. https://manalyzer.org/report/03b2253bcbb611502eba5b43df3e1dc... is one such example.

EDIT: Example EPL code https://gitee.com/yyman001/RightHand/raw/master/%E5%8F%B3%E9... presumably this is in GKB encoding so it's mostly garbage characters.

EDIT: https://www.hexacorn.com/blog/2019/02/13/pe-files-and-the-ea... someone wrote reverse engineering an EPL executable.

USSR did it for Russian: https://en.wikipedia.org/wiki/Rapira

Wasn't a bad language btw. Support for pretty large numbers (up to 2^1016) out of the box, for example. Flexible data types (e.g. sets, tuples, structures, etc.). Optional typing. Not too bad for early 80s.

I’m not sure the merits of using this in production but as a tool for introducing someone to programming this is awesome.

Agreed. Non-english for introduction is good. But for production it is going to impede collaboration and your understanding.

As a non native speaker, I have seen my friends struggle with english in grad school when they were taught math and science in their native tongue. This is a different programming language not just python with spanish variables. Translating to english and then having to translate the code later on, is going to be a huge barrier.

Other Spanish-based programming languages:

* PSeInt (http://pseint.sourceforge.net/)

* Pauscal (http://www.pauscal.com.ar/

* IIRC, Logo has some Spanish interpreters

There are 2 popular programming languages of Latin American origin, Lua and Elixir, both from Brazil.

This initially thought this would be a nice tutorial/community for Spanish speakers but it appears to be that they are attempting to write a new programming language.

I’ll have to say I prefer the idea of educational site that explains and talks about the idea of programming and what not.

The person who builds that educational site now has an entire language their students can read and write in.

I prefer the idea of a non-English programming language being used in production at scale. Not for technical reasons, but it just seems a little unfair that anyone who is not a native English speaker is at an automatic disadvantage in tech.

Memorizing a few foreign language keywords is certainly the smallest challenge here. You will have to do so anyway, no matter if in a foreign or your native language. It is incredible to me that anyone could seriously suggest this would make any kind of difference.

I started coding when I was a kid of 12 and certainly not (yet) good at English. If anything, my computer hobby helped me pick up more English just by the way, than I would have without it at that age.

Heh, I just wrote a reply saying essentially the same as you!

English keywords in languages aren't an impediment.

In general, Spanish-speaking programmers aren't at a disadvantage because of English keywords in programming languages. When I started coding I barely knew English, and I still understood Commodore BASIC's keywords -- even if I pronounced all of them wrong.

The impediment to learning programming is the conceptual load of what the keyword means, not the language. You're already learning a new language with new "words" (e.g. BASIC), what does it matter if it's LOAD or CARGAR, RUN or EJECUTAR, PRINT or IMPRIMIR?

The real impediment for Spanish-speakers learning programming is that the vast majority of articles on cutting-edge tech are written in English. This is changing, but back when I started about 99% of articles/manuals were written in English. It only helped me learn English faster, though. (Videogames -- text adventures and the like -- were the other motivation).

Ding ding ding!!

People forget that there is the English internet, which is wholly different than the other languages.

The idea of a lingua franca in science and business is a net positive to be able to unify and communicate effectively. If anything we need to teach this idea better.

How do you tell someone they are in a smaller fish tank than they currently perceive?

This is less important but I think English is a better source of language keywords than romance languages. English has a lot of short, punchy words due to its germanic origin. Even as a Spanish speaker, the Latino code samples look tedious compared to the English keyword equivalents.

Except English borrows heavily from Romance languages.

I think you think that you're disagreeing with me, but you're not. English borrows heavily from Romance languages ... and it is also of germanic origin and has a lot of germanic origin words.

What exactly is in English within Python? There’s but a couple keywords used, and the phrasing things of “for x in y” is something like “para x en y” or similar isn’t mind blowing.

Not just that, but given that many inventions and concepts are American (mostly), they have to use “retornar” instead of “return”. Again, not a big leap even for a young kid in Buenos Aires.

If anyone else is confused, the language has Spanish keywords. My browser automatically translated the code snippet into English for me, leaving me wondering why the language "has received the love and support of Hispanic users around the world".

Couldn't this be accomplished in a language like C++ using macros/typedefs/templates? Just make an alias for every single built-in keyword/type in the target language. Would be an interesting experiment, although you would still have to translate all the libraries that do the heavy lifting, which would be monumental effort... might want to automate it using something like Google Translate, and then review it for quality with a native speaker.

Good luck searching for online documentation and StackOverflow answers in your new bespoke language. You'll probably need an interpreter that translates your search queries back into the base language syntax.

Very cool. I am also working on a non english programming language. Github repo: https://github.com/Shafin098/pakhi-bhasha

I vaguely remember Applescript used to be internationalized a long time ago.

The keywords would display in different languages.

That said, why can't other languages be internationalized, maybe in the editor?

I think it would be fun to program in spanish.

  siesta(5);

I don't dislike the idea but, as a Spanish speaker, my first impression reading the main page could be notably better:

- Typos: "cabezera", "al rededor", lots of tildes missing in general

- Google "translade" [sic] allowed - Why even ask for translators in the first place then?

- Filler text still present ("esto de prueba")

It seems that the author is not a native Spanish speaker, or at least not an idiomatic one.

I remember from my times at the university that the TI Voyage 200 (and probably TI89, too) had the option to program in different languages. I tried the Spanish version, but apart from being an interesting exercise, I didn't see much use in programming in Spanish. Furthermore, if I remember correctly, if you wrote a program in Spanish, then it would not run after you set the language back to English... so not so good if you wanted to interchange code.

Spanish is my first language, if you use this you _severely_ hamstring yourself. Don't do it.

English is the world most used programming language, just learn it. Or perish.

I also feel this effort is completely pointless. Java for instance has 52 reserved words. 52!!! the complexity of programming does not lie in the meaning of just 52 english words. That's actually the easiest part. As you get better you eventually will pick a production-ready language such as JavaScript or Kotlin, only to realise that you now have to learn the meaning of the words...

I always wondered why there weren't more non-English programming languages...it seems like it gives an incredibly unfair advantage in compsci for Americans and British and Irish compared to most other countries in the world. Programming is hard enough to learn even when you speak the main language, let alone having to learn English in the process as well.

There are more than a few, but none of them are nearly mainstream:

https://en.wikipedia.org/wiki/Non-English-based_programming_...

A lot of these start as passion projects by native speakers and don't gain much traction. Actually, here's one that was posted just over the weekend, so maybe didn't get a lot of attention: https://news.ycombinator.com/item?id=26771369

Yeah, I figured that they have to exist (didn't see the Cree one, I will look at it) just due to "law of large numbers" reasoning.

It always just seemed a bit weird to me, there are more native Spanish speakers then English speakers...why has English become the lingua-franca for a base of programming languages? Is it as simple as "Apple, IBM, and Microsoft started in the US"?

Well most were created in C like, Lua made by a brazillian, Ruby made by Japanese guy. So yea they already had to base of existing US tech.

I think it comes down to the fact that the predominate view of programming languages is that they are math and tools for conducting science/business. English was the lingua-fraca for science/business long before programming languages were around so it might have followed naturally that programming languages should be localized in English as well.

But it's hard to say, there are a lot of cultural elements at play. We see one right here in this very language that is trying to escape the English domain -- it doesn't have support for character accents native to the language it's trying to support. This limitation probably derives from the days when bytes were highly expensive, so character encodings had to be frugal with their use of memory. With one byte you can encode enough characters for the English alphabet, numbers, symbols, and control characters, but you're not going to have enough for all the combinations of accents. Just look at what went into the extended ASCII table: they made room for some common accented characters from western nations, but also allocated precious space for copyrights, trademarks, fractions, legal symbols, more mathematical operators, and currency symbols of the largest nations. More than a purely technical decision, this is a statement of priorities.

Again you see programming-as-math/science playing a role here; character encodings for mathematical symbols were given priority, but characters that could be used for communicating in other languages were disregarded. This is likely because the kinds of applications people were looking to use programming languages for were based in math/science, so those symbols were viewed as indispensable. I'm not saying this was wrong, btw, I'm just saying that's the way these things evolved.

This very early (circa 1960) decision still has rippling consequences even today, so it's clear momentum of early choices in computing plays a large role here.

Because if you use a keyboard with the latin alphabet, the language of the keywords is not a big deal. What's important is for the tutorials and documentation to be translated, not the language itself.

When you use a non latin keyboard I guess having a language matching your keyboard might be more important.

I'm "that guy" who, if I see a stackoverflow question that has code (i.e. variable names and comments) written in non-English (making me work twice as hard to make it work), I passive-aggressively post an (otherwise correct) answer in Greek code (i.e. my own native language).

I know it's a dick move, but I stand by it. :p

How about a macro system that replaces keywords in any natural language for any programming language? This would be only an i8n layer that doesn't mess with any core functionality of the programming language.

As long as you don't support COBOL, it should be pretty straightforward.

Edit: Maybe not so straightforward!

A consequence of this is that you can't use keywords from any language for your symbol names. Or, I guess, you could do like Perl and defined symbols need a $ prefix or somesuch

This would be easier with languages where keywords are in clear and consistent syntactic positions and identifiers can match keywords (that is, the keywords are only "kind of" special, more by position than value).

Otherwise, you'll run into issues when someone is using Language X but has identifiers that happen to coincide with Language Y's keywords. You wouldn't want to error out here, and you don't want Language X writers to be forced to be aware of the many hundreds of extra keywords that are now required knowledge to avoid collisions and permit universal translation.

For instance, in a programming language which uses `and` as a keyword in English for the logical operation, this would be translated into Spanish as `y`. Well, in graphical applications `y` is a perfectly natural variable name for the English speaker (and probably the Spanish speaker, but their dialect of the language wouldn't permit it). Now the English program can't be translated properly into Spanish unless the syntax is such that variables and keywords are always unambiguous so that this can be legal in the Spanish version:

  y < 0 y x > 10
  y < 0 and x > 10

Of course, switching to a language which prefers symbols over keywords would help to minimize this issue (as in C where `and` is not a keyword, in contrast with Ada where `and` is a keyword).

Here are some code examples for anyone curious to see how it looks

https://github.com/lenguaje-latino/latino/tree/master/ejempl...

My first impression is that it looks like a mix of Lua and Python.

> Latino es un lenguaje de programación con sintaxis en Español creado en C, inspirado en Lua y Python

Well, yeah....

I don't see much Python, mainly Lua with Spanish keywords and function names, basically. while => mientras, if => si, end => fin, break => romper, print => poner, etc.

I learned programming with such a "localized" version of simplified FORTRAN, but I didn't find it intuitive or conducive to learning how to program. Later, I read a study (can't cite it; lost the details) that found interference from programming language keywords in English speakers, but not in others, and they suggested it might actually be easier to learn programming with English keywords.

It says it has local-by-default scoping, which would be a Python influence. But now I'm not sure. When I tested the program the variables set inside the function seem to still be present after the function returns?

I love the idea, but this an especially un-Google-able name for a programming language.

https://github.com/wenyan-lang/wenyan the ancient Chinese programming language is way cooler than this

If software is “eating the world”, it is inevitable that local dialects will arise. I wouldn’t be surprised if the world of 2100 is full of popular non-English programming languages.

If anything, it seems to be going the other way to me. In Europe, programming jobs only requiring English (and not the local language) seem steadily on the rise, because it means companies can pull talent from other parts of Europe, or even further abroad.

If you're a German company that wants to also be able to hire coders from France and Italy and Romania, requiring German proficiency is going to drastically cut down the potential international labor pool you can draw on. And that's for one of the biggest European languages -- imagine what the calculus is if you're a company in Denmark or Slovenia.

Plus, let's say you start with the local language, but then your company gets big. At some point, you may want to open up offices in other countries...but what do you do then? Have German source code from your German devs, and French source code from your French devs?

The EU is a particularly unique situation where a unified language is useful and that language will probably be English.

Latin America, for example, isn’t the same.

Awesome! I have always wondered if language like spanish and arabic have (widespread) programming languages.

As an aside: I guess the fact that k only uses symbols makes it a very inclusive language :)

If you're going to use Spanish keywords, atleast spell them correctly. Is it that hard to use "función" instead of "funcion".

I thought it was slightly funny that I can read the Latino programming language better than I can read Spanish, despite never seeing the former.

This is certainly fun to look at. Thinking about this, are there any programming languages that do i18n for their keywords?

I have feeling someone German/Russian is already working on this one. Davay geht los :)

Another native speaker here. I disagree with most of you.

When I was a kid I played a Captain Tsubasa NES game that was completely in japanese. I have no idea of the meaning of the Kanji characters I choose but I know pretty well what I was doing in short time. I could play the game through trial and error. So no, you don't need to know actual english to code.

Now, you and me were invested. We want to code and we were willing to learn how to code even without knowing what was the meaning of the english words we use. Just like the way I played that game. A lot of people is learning how to code like they learn basic math. They are not invested. They know is useful however didn't want to learn it. This tool is good for them.

I still don't like the name and also don't like they don't allow tildes and ñ. I also think scratch.mit.edu is a better tool for people starting to learn how to code.

What kind programming paradigm does it use?

It wasn't clear from the website.

What is next? Programing Languages based on Race color?

Remember COBOL, this is a path towards a v2 of that disaster.

Yikes. Same level as people using latinx.

why call it Latino and not Spanish? Latino includes Portuguese, and this is Spanish.

sounds good for introduction to coding for kids in non-English speaking countries.

Spanish speaker here. My experience is that English keywords in programming languages aren't an impediment. Most other programmers in my country (and others, judging by what I read) share my experience.

Localized keywords don't translate well to a later experience with programming languages at large.

Kids in the 80's learnt Basic in English just fine. Even basic terminology such as input, output, load, save and so on. Also we began to learn English by age 8-10 or so, so is not an issue. As they stated, the biggest issue is that the documentation itself is, by a huge margin, in technical English.

WTF is this? LOL

That's a great way to make programming more accessible.

Reply on news.ycombinator.com