Can interpreter flags causing major language differences be considered different versions of the language?

Question

I recently (this morning) extended Cubically to have an internal cube of variable size. The cube size is passed via a third interpreter flag (3 for a 3x3x3, 4 for a 4x4x4, etc).

All mathematical operations will differ based on the size of the cube. Attempting to add 26 and print it would be a different process in "Cubically 4" (4x4x4) than it would be in Cubically 3.

So, I'm wondering, since the code in Cubically 3 will do something else in Cubically 4, and something else in 5, and yet another thing in 6...

• Are they considered different versions of the language?
• Can I use different Cubically "versions" in polyglots?
• Do I need to add 1 byte to my score for Cubically 4, as Cubically 3 is used by default, but Cubically 4 requires -4 to be passed to the interpreter? What about Cubically 26?
• Can one person complete a challenge in Cubically X, and someone else answer the same challenge in Cubically Y?

Answer 1

Answered in order

Yes

They are different versions.

Maybe

It would depend upon the challenge in question. Some specify that major versions (e.g., Python 2 vs Python 3) are considered the same language, some have them different.

No

Just like how Perl and other languages get certain flags "default" for free, the same would be for this. If it's required for a -4 to be present for Cubically 4 to compile/interpret/run/whatever, then the -4 is a free flag.

Sure, why not?

We even allow answers in the same language, so what would be wrong for answering in two different versions of the same language?

Answer 2

This needs to be handled on a case-by-case basis, but looks fine here.

We shouldn't make a blanket statement that interpreter flags define a new language version. This runs in to the MetaGolfScript problem, where different languages essentially encode part of the code.

In this case, however, the languages are substantively different, so I think it's fine.

Answer 3

Just addressing number 2

I agree with AdmBorkBork on all the other answers so I am just going to respond to the second question you ask.

Yes

You can make a polyglot between them. As I see it there are two types of polyglots

• Polyglots where different languages output different results

• Polyglots where different languages output the same result

The first type easily resolves itself, if they output different things they must be different languages. The second case is a little more complex, but reiterating what I said here, the question asker should really define what they mean by different languages, not rely on the meta to do it for them. This means that if the difference in flags causes a difference in behavior sufficient to qualify for the difference in language, then they are different languages.

Answer 4

Maybe, Maybe, Maybe and Maybe

• Well, for one thing, I would follow this consensus for deciding if they're different versions.
• Same as above for polyglots.
• I'd say that you should count the size like normal command-line flags, depending on the current consensus here.
• On duplicate answers, it would depend on the consensus here.

Answer 5

No, they are all the same language

We define a language by its implementation, nothing more. Simply because you can pass in a flag to change the behavior of the language doesn't change the fact that you've still only implemented 1 language.

Making them each different languages is a slippery slope where people can make a MetaGolfScript where each "language" is defined in the flags.

If you released 3 different executables that didn't need any flags (for the sizes 3, 4, and 5), then at that point in time, they would be different languages.

In case these concerns come up:

• The problem with MetaGolfScript is that the language isn't defined before the challenge
  • True, but following that logic, neither is Cubically 28751.
• This isn't an attempt to cheat in order to scrape off some bytes. We don't need to punish those that aren't trying to break the rules
  • We're already trying to make things more standardized and consistent in our rulings. This isn't the time to start making exceptions for various languages.