Say you're implementing a field-specific solution, do you use the US English term or the term that's written on the users know? (specs, documentation, etc)

If another developer comes on board, will their English be fluent enough to know those terms? There's also a huge risk in having a translation error. We're programmers, not translators.

For general variable names, I agree. On the other hand, in my experience, when the programmers aren't fluent enough in English, if English is imposed, they tend to choose really bad variable names and not comment their code properly. So I tend to impose clear names/doc over imposing a specific language.

In Poland it is generally assumed that a programmer knows English, most of the companies here are just branches of companies from other countries (not only US/UK based) and to communicate we use English as a common ground.

Another factor to consider is that if we write in language that has some constructs (e.g. C - if/then/else/while/return/int/double/class/void etc.) then writing:

    if (znalezione) {
       ...
    }

looks awkward.

Also one has to consider popular libraries and functions/methods/classes in them are English based, so this would add even more awkwardness to the code:

    zwierzęta.stream()
        .filter(z -> z.kończyny().contains(noga))
        .map(z -> z.toString())
        .collect(Collectors.toList());

As I said, I'm not talking about the basics, but more especially for field-specific terminology, comments, etc.

I agree with you, but the example you gave is more common than you think. We tend to over-estimate people's language skills. (keep in mind, English is not my native tongue, I'm including myself in there and it's not meant as an attack, just something we need to deal with, and I would not outright exclude bilingual code)

One problem for a startup (as opposed to a consulting firm), is that you would eventually want to have geographically distributed offices and teams, though. So if you start with a code-base in something other than english and then end up opening an office in Ireland, Germany, Singapore or India you will likely end up rewriting into english anyways (never mind the Bay Area, Seattle or NYC, which you will likely need before your company reaches 10,000 developers...).

> If another developer comes on board, will their English be fluent enough to know those terms?

That's why my startup uses language-neutral variable names like i, j, k and x, y, z.

Some advocates of code "expressiveness" would like (or perhaps dread) a word with your lead... ;)

Joke aside, for anyone curious: we use such i, j variables for abstract logic like a counter (e.g. i=0 at the beginning of a loop, and gets incremented by 1 each time the loop runs), or booleans maybe (e.g. P=0 or 1, true or false). But generally it is considered good practice to give names to variables that are self-explanatory (e.g. studentName or vehicle_age) for readability and ease of understanding. Even counters and booleans should be significant when possible (e.g. "hasResponded" or "day_num").

On topic, I think english or not doesn't matter theoretically. Its cultural and indeed 80% of computing/code happens in english on earth (no source, waddayathink!). What matters imho is that semantics are correct (both human and machine language...) and reasonably meaningful to a collaborator.

To anybody wanting to know better: read open-source code. Best school there is, actual practice.

  I can't imagine naming variables using any other language but English.

I spent some time as a consultant auditing other companies' software. Even with platforms where the coding-standards dictated the use of English, most of the projects I audited in Europe used the local language, rather than English - especially in variable names.

Admittedly there was a selection bias - I wasn't ever hired to audit perfectly good software - but it was remarkably common.

>>English is most of the times more concise than my mother language (Polish) [...]

If one were to pick Polish variable names, would the default be the neutral forms[1]? I'm sure this applies to other languages that also have forms of complex declension compared to English. Which would make more sense in Polish?

[1] https://en.wikipedia.org/wiki/Polish_grammar#Nouns