Which language's style guidelines should be used when writing code that is supposed to be called from another language?

Question

This is just a simple code-style question. Imagine you're writing a function in language 1 that is supposed to be called from language 2. Should the function follow language 1's style guidelines or language 2's style guidelines?

For example:

// This file is written in language 1
// Language 1 uses `PascalCase` and language 2 uses `snake_case`

// Follow language 1's style guidelines:
function FunctionToBeCalledFromLanguage2() {}

// Or language 2's:
function function_to_be_called_from_language_2() {}

// This file is written in language 2
// Language 1 uses `PascalCase` and language 2 uses `snake_case`

// Call the function from language 1
language1.FunctionToBeCalledFromLanguage2();
// Or:
language1.function_to_be_called_from_language_2();

Answer 1

In general: when you write some library in language 1, you use the conventions from language 1, and use an alias mechanism to provide an API to map the function names to the case conventions of language 2.

The only case where you might skip this additional API mapping is when you know for sure that your library written in language 1 has the one-and-only purpose to provide functions for "language 2" and no other language environment at all. Then it might be simpler to use conventions from "language 2" directly for the library API (but you should check if that is really the case).

Answer 2

I believe you should follow the conventions of the language you're writing in, with few exceptions, for these reasons:

1. You say that the function is "supposed to be called from language 2", but it seems unlikely that can you guarantee it will always be called from Language 2 in the future.
2. The people best suited to maintaining the function will be the people who are comfortable working in the language it's written in, and they will be best served by following the conventions they are familiar with.
3. An IDE and perhaps even a compiler will output warnings for violating those conventions.
4. Except in exceedingly rare circumstances, calling functions in language 1 from language 2 is not a new problem that you are solving on your own; this is something other people have dealt with. People working on interop software should be familiar with seeing such function name styles. They may even find it more confusing if the name violates Language 1's conventions.

I think that you'll also find this isn't a significant issue in most candidates for Language 2. In Java and C#, you can't simply call a function by name like that, anyway; you'd pass a string to a loader function, e.g., NativeMethods.GetProcAddress(pDll, "FunctionToBeCalledFromLanguage2");, making this entirely a non-issue. Groovy supports invoking Java functions directly by name, but it has the same naming conventions, obviating the question.

Answer 3

There is no definitive answer. Coding style is subjective.

However, I think it would be a sane general rule, that when you choose a coding style, you choose it for the readers of your code. Who would be your primary audience?

• If you are writing for an audience that mainly uses language 2, your function names should follow language 2's coding conventions.
• If however, you are writing for an audience that mainly uses language 1, and the function you write, will typically be abstracted away from language 2 users by a wrapper library, you should choose language 1's coding conventions.

Answer 4

I would write a wrapper API in the client language 2 to call functions implemented in language 1. Good thing to do anyway as may simplify various cases of refactoring later.

Then, just inside the wrapper, I would call functions of the language 1 named by the rules of the language 1.

The wrapper may also convert the passed or returned data structures between representations that are more traditional for another language. For instance, with Python ctypes, Python list cannot easily go right into C++ layer but some conversion may be possible.

Answer 5

I would use function_to_be_called_from_language_2(); forget about style guidelines..

function_to_be_called_from_language_2(); is much more readable at first glance than FunctionToBeCalledFromLanguage2

Aside from performance we should always prioritize readability of the code

"but it doesn't follow the style guidelines!".. who cares?

This statement "write an alias mechanism to provide an API to map the function names to the case conventions of language 2."

Could be translated as:

"Waste your and the companies time by writing the alias mechanism with the end goal being making the code less readable"

Doesn't sound very logical to me?

If the style guidelines had you define a method name like this

function GeTcArViNnUmBeR()

Would you follow them? I should hope not.. because those type of style guidelines would encourage you to make the code less readable..

Is that not the case here?

Answer 6

First investigate if the compiler / linker / tools are able to change the names to adapt to the language used.

As an example, the names of methods in Objective-C often have semantics. Like a method beginning with “init” have special meaning. When using these methods from Swift, the name is automatically mapped to a different name with the same meaning.

And once in a while you have a case where this doesn’t work. Where something matches this semantics pattern by coincidence. For these case you can tell the Objective-C compiler what the Swift name would be and vice versa, and actual code looks fine in either language.

For other situations: Consider writing code that is fine for the implementation language and add a wrapper that is only ever used by the calling language.