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

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?
• The different Klein variants are considered their own langs. – Pavel Aug 9 '17 at 19:23
• @Pavel Oh, that's definitely good, because this is pretty much the same thing. – MD XF Aug 9 '17 at 19:26
• @Pavel According to meta consensus, no, Klein has to pay 3 bytes. meta, but I personally disagree with this ruling and generally don't add it to the score. – Wheat Wizard Aug 9 '17 at 20:35

### 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?

• So if the challenge specifies that different versions of the same language may be used, I can use them? – MD XF Aug 9 '17 at 19:34
• @MDXF I would say so, yes. – AdmBorkBork Aug 9 '17 at 19:35
• Does a challenge need to specify that different versions do count as different languages or that they don't? Do we have a default? – Shaggy Aug 9 '17 at 22:41
• @Shaggy Languages are defined by their implementation, so the default is that major versions are different languages and thus can be used for polyglot or other such challenges. – AdmBorkBork Aug 10 '17 at 12:31
• Wait, so if cubically -4 is a different language than cubically -5, then why doesn't that apply to all flags? Where does the line fall? – Nathan Merrill Aug 17 '17 at 19:45

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

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.

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

# 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.
• I agree with your last point. We should not make exceptions for languages. However I disagree with your solution. I think instead of all flags being counted no flag should be counted. Our flag rules are doing much more harm than good at this point and are still wildly unintuitive. – Wheat Wizard Aug 18 '17 at 0:17
• @WheatWizard so you'd argue to close the Meta-Flag-Golf-Script loophole another way? – Nathan Merrill Aug 18 '17 at 1:20
• We already allow new languages made after the challenge, I think we should just treat answers in Metagolf script the way we treat answers in languages intended to abuse this rule. – Wheat Wizard Aug 18 '17 at 2:08