What's a good term for source code that could theoretically still run, but is purposefully not?

Question

I'm a software engineer. There are many times when I write a good chunk, or even the entirety of, a feature, but opt not to make it actually run in the program for some reason or another. This code is still there, and could theoretically work, but it never will because it's inaccessible.

What's a good one-word term for such code? I want to use it, or a form of it, like this:

"This is ______ code."

"I am going to ______ this code".

---

Terms I considered (but don't seem to fully-convey the purpose) include:

• frozen/freeze (implies it causes the program to freeze?)
• isolated/isolate (implies it can be run in some isolated environment)
• vitrified/vitrify (implies it's changed to something else and can't change back)
• fossilized/fossilize (implies it's old and broken and should only be observed. Same problems as vitrified)

Answer 1

I'm rather thinking of the word unused.

Edit: Unused should be understandable for non technical persons. Other possibilities include unnecessary (you often see this in change logs, as in removed unnecessary lines) or maybe orphaned (although I haven't seen this in a real coding situation. It's rather a translation of a term in my native tongue)

Answer 2

It's called unreachable code.

"Unreachable code" is different from dead code, dead code is code that when executed will result in no change, for example:

x = 5;
/* Dead Code Begin */
x = 6;
x = 5;
/* Dead Code End */

Unreachable code however is code that e.g. in a function that is not referenced anywhere, or code that is after the return clause of a function, this code is present, and theoretically compiled, but can never be "reached" to be executed.

Edit:

Many are claiming that this is not the correct answer and it is not cited anywhere, even though I see wikipedia's distinction is enough, I will quote MISRA C 2012:

Section 8.2 Rule 2.1: A project shall not contain unreachable code

Rationale

Provided that a program does not exhibit any undefined behaviour, unreachable code cannot be executed and cannot have any effect on the program's outputs. The presence of unreachable code may therefore indicate an error in the program's logic.

Then the rule directly after that:

Section 8.2. Rule 2.2: There shall be no dead code

Aplification

Any operation that is executed but whose removal would not affect program behaviour constitutes dead code.

.

.

.

Note: unreachable code is not dead code as it cannot be executed.

And before someone comments that it is saying it is a mistake and not intentional, MISRA exists exactly so that when you break one of its rules you justify why you did that and that it is intentional, otherwise the violation should be removed, but it does not change the definition of what is unreachable and what is dead code.

Answer 3

Since the code is inaccessible, most compilers will eliminate it through Dead Code Elimination, or DCE. So you can refer to it as dead code, or simply dead.

Nullstone's compendium of compiler optimizations defines dead code as

Code that is unreachable or that does not affect the program (e.g. dead stores) [and] can be eliminated.

Since the code is apparently not going to be run, you can also say it is excluded from the build. So, to complete your sentences:

This is excluded code.

I'm going to exclude this code.

Answer 4

RTCA DO-178C - the standard for safety critical code in aircraft - uses the terms "dead code" for code that is never reached in any path through the code. The term "deactivated code" is for code that is deliberately never used in a particular configuration, but could be used in a different mode.

Answer 5

You might consider disabled or deactivated:

disable: to cause (something) to be unable to work in the normal way
deactivate: to make (something) no longer active or effective
_{definitions from merriam-webster.com}

Answer 6

moth-balled

verb (used with object)

2. to put into storage or reserve; inactivate.

adjective

3. inactive; unused; stored away:

Answer 7

When discussing code or functionality that is either in progress or completed but has not been approved or won't be used, we often use the term

shelved

decide not to proceed with (a project or plan), either temporarily or permanently.

This implies that it was not a failure (which would be "trashed") and that it could later be unsheleved and put to use.

example

Answer 8

My view is that such code should not exist in the code base and is a code or process smell.

This is cluttering code. I am going to clutter up the codebase with this code.

Answer 9

I would use the word "inactive" since it is possible to use that code, yet it is not actually doing anything, as you have stated.

Answer 10

I originally posted this as a comment, but will add a meaningful and expanded answer. As a software engineer myself, I'm using generic term redundant code.

"Redundant code" fits perfectly almost for every case:

• when part of code is unnecessary,
• or is not in use,
• or it's unreachable,
• or is unreferenced,
• or is not used in computations,
• or optimized out by compiler.

Redundant code is generic term, it defines the category of the code. If you need to clarify, why it's redundant, you may use more explicit terms, depending on the context:

• unused code – part of the code, which is never used in any computations, the logical rules never lead to execution of it, or it can be just commented code;
• unreachable code – part of the source code which can never be executed because there exists no control flow path to the code from the rest of the program;
• dead code – has no external effect: e.g., does not change the output produced by a program, result is never used in any other computations, and normally may be optimized out by compiler;
• legacy code – is source code that relates to a no-longer supported, not-maintained anymore, and could be partially not in use. This definition might be a bit blurry, and these conditions are not necessarily part of the term, it mainly depends on the context of usage;
• unreferenced code - subtype of dead code, unused code, i'd say.

Answer 11

How about auxiliary code (auxiliary/auxiliarize): something that's useful but unused, held in reserve in case it's needed.

(I also like vestigial code, but that's not as good an answer, since it might imply obsoleteness).

Answer 12

I would call this feature toggled code. If you read the linked post you may come away with the impression that you must use configuration to toggle features. That's true. Your configuration just happens to be hard coded right now.

You may want to fix that, but even if you don't, I think "toggled off" is a reasonable description of this code.

Answer 13

I'd use dormant. As per the verb I'm not sure if there is one for make it dormant otherwise I'd just say that.

ADDED: This term would be a metaphor about something currently inactive but that has the full potential to do things if it gets activated, f.ex. a dormant volcano, or a dormant spy living an apparently normal, unrelated life but that can be activated as a spy in the future.

Answer 14

I would use the word hidden:

kept out of sight; concealed.

synonyms: concealed, secret, undercover, invisible, unseen, out of sight, closeted, covert; secluded, tucked away; camouflaged, disguised, masked, cloaked

"This feature has been implemented, but it's currently hidden from users."

Answer 15

One term is crippled. As in "the freeware version had several functions crippled."

https://en.wikipedia.org/wiki/Crippleware

Answer 16

After reading all of the other answers and OP's comments to them, I now have concluded that the code in question is complete, and it just isn't being used anywhere yet. (Imagine a method overload or helper function that no one is calling yet.) Therefore the most sensible option I can think of that other programmers would instantly understand is:

uncalled
or
unreferenced

The thinking here is that after the entry point, all code is potentially called by other code. You have code that is not called by other code anywhere yet. Compared to some other answers I like, this is very similar to unused, with the minor difference that uncalled is more targeted specifically to code, whereas unused is a broader term which can be applied to many things, one of which is code.

Some other terms that were mentioned that I'd like to comment on:

• orphaned - this is similar, except that it suggests that at one time the code actually was called somewhere, and now it isn't called anymore.
• shelved - I originally liked this answer the best, because I thought the wrong question was being asked. I thought a better question would be: "What should I do with this code that I don't want to use right now?" But that isn't quite the same thing as "What should I do with this code that I don't want to use right now, but someone else might want to use right now?" In the latter case you don't want to shelve it because someone could legitimately want to use it right away, and I believe that's a better description of the scenario in the question.

Answer 17

You could consider suppressed:

to keep in or repress.

to withhold from disclosure or publication.

(Dictionary.com)

That conveys not only that the code is unused, but that it is intentionally prevented from being used.

Answer 18

I would use inactive to indicate that it is not being executed in any existing code path.

From your example:

"This is inactive code."

"I am going to activate/deactivate this code".

Answer 19

I think the word you are looking for is "sideline" (sidelined).

past tense: sidelined; past participle: sidelined

cause (a player) to be unable to play in a team or game. "an ankle injury has sidelined him for two weeks" remove from the centre of activity or attention;

place in a less influential position. "backbench MPs have been sidelined and excluded from decision-making"

Answer 20

There are several good answers here (and a few that, IMHO, are not so good).  A couple of them mention the word "reserve" in passing, but don't propose it as an answer, so I will: reserve or reserved:

transitive verb:

1. to keep back or save for future use, ...
3. to set apart for a particular use, purpose, service, ...

adjective:

15. kept in reserve; forming a reserve: a reserve fund; a reserve supply.

For the answerers who suggest that such code should be deleted, is a waste of time, is clutter or obsolete, consider this scenario: Programmer thinks of a neat new feature for a product and codes it.  Her manager says, "Yes, that's neat, but our marketing plan for this product calls for a new major version six months from now; let's keep this in reserve until then."

Answer 21

Depends on why you disabled it. You could perhaps be more descriptive about why you disabled it rather than looking for a generic "____ code". Here's a few generic words:

• Disabled
• Unused
• Stashed

And a few specific ones:

• Uncontrolled
• Untested
• Deprecated
• Obsolete
• Non-production ready

Answer 22

I do believe this is called Dormant Code, a variant term from Unreachable code, because Unreachable code is most of the times an error effect as stated above as

programming errors in complex conditional branches;

a consequence of the internal transformations performed by an optimizing compiler;

incomplete testing of a new or modified program that failed to test the bypassed unreachable code;

obsolete code that a programmer forgot to delete;

and not a purposeful actual cause; I would term it Dormant Code, because it's functional code that you chose not to turn on but it's there whenever you need and if you trigger it; if you can't actually FIND the code although it's functional AND working, then the term is Hidden code not Dormant code. HOWEVER, if Kojiro's concept for the code fall in these:

unused code that a programmer decided not to delete because it was intermingled with functional code;

conditionally useful code that will never be reached, because current input data will never cause that code to be executed;

then it can be placed inside the construct of Unreachable Code

Answer 23

If we borrow what git calls code you store away for later, try stashed.

It does not come up often in casual conversation so there is unlikely to be conflicting usage.

Similarly, there is also stored.

Answer 24

legacy code, used primarily for informal pseudocode