As a software engineer, I need to sometimes describe a piece of code as something that lacks performance or was not written with performance in mind.


This kind of coding style leads to unmaintainable and unperformant code.

Based on my Google searches, this isn't a real word. What is the correct way to describe this?


My usage of "performance" here is in regard to speed and efficiency. For example, the better the performance of code the faster the application runs. My question and example target the negative definition, which is in reference to preventing inefficient coding practices.

  • 2
    The first sentence is exactly what's not clear to me. What do you mean by "lacks performance"?
    – Rupe
    Commented Jun 23, 2014 at 16:41
  • 1
    Related (possible dupe): english.stackexchange.com/q/38945/8019. Commented Jun 23, 2014 at 16:42
  • 3
    Do you mean it gives the wrong answers? Does it give confusing or less than accurate answers? Dp you mean that it takes too long by some arbitrary metric? Does it interfere with other processes running concurrently? Does it actually leak memory or file descriptors or file locks or other resources? Does it use a lot of memory? That its code is spaghetti code? Is it hard on the filesystem? Does it have some nonlinear explosion based on input size? Performant is a mincing weasel word at best.
    – tchrist
    Commented Jun 23, 2014 at 16:45
  • 5
    In fact let's take it back and ask what you mean by "performance". Are you talking about efficiency, stability, accuracy, what? The only kind of code I can think of which might be written with no aspect of performance in mind, would be code snippets used for teaching purposes.
    – Rupe
    Commented Jun 23, 2014 at 16:46
  • 7
    Why do you need to find the inverse of the non-word "performant"? Why don't you just say slow or inefficient, depending on what you actually mean? If you don't know what word you're looking for, chances are your audience won't know it either. Simplify. There is no reason to use myriad instead of many, utilize instead of use, etc. Commented Jun 23, 2014 at 19:51

7 Answers 7


This kind of coding style leads to unmaintainable and unperformant code.

In my opinion, reads more easily as:

This coding style leads to unmaintainable and poorly performing code.

The key to well-written documentation and reports lies in ease of understanding. Adding poorly understood words such as performant decreases that ease.

In addressing the use of such a poorly described word as "performant", I came across the following lovely excerpt:

"The unlovely language of this unreal world floats along on a linguistic sea of rollouts, step changes, public domains, fit for purposes, stakeholder engagements, across the pieces, win-wins, level playing fields and going forwards," the report says.

I believe this wholeheartedly encapsulates the why's and wherefore's of not using vernacular that is imprecise, vague, and designed to confuse.

Sir Humphrey Appleby, in 1986, put it fairly succinctly when he stated:

‘Sometimes one is forced to consider the possibility that affairs are being conducted in a manner which, all things being considered and making all possible allowances is, not to put too fine a point on it, perhaps not entirely straightforward.’

See http://www.theguardian.com/society/joepublic/2009/nov/30/english-language-misuse and potentially, http://grammar.about.com/od/words/a/Doublespeak-Soft_Language-Gobbledygook.htm for more examples of why it is important to speak plainly and in a manner that allows ease of understanding.

itshambles.wordpress.com has an excellent piece on the vagaries of wholly unknown and unknowable language. The writing is both informative, and quite funny, and obviously well worth the read.


The word "performant", meaning "performs adequately or well" appears to be a relatively recent coining. Some people object to its use as it is not clear about what kind of performance it is referring to.

If you accept the word performant as a valid, useful word, you will then be dismayed to find that there isn't really a standard for its inverse. However, you are probably safe using non-performant as it follows fairly typical rules for creating negative words. Note that non-performant is even more non-standard than performant, and neither word carries much specific meaning. It may be better for you to be more explicit about what kind of performance is lacking.

  • 6
    I think you've outlined the caveats really well here. To my mind, performant is a jargon usage too far (even more so for derivatives thereof), but I'd have no problem at all with underperforming. Which is very likely what OP means - not that it doesn't perform at all, but that it doesn't perform as well as it should/could. Commented Jun 23, 2014 at 17:20
  • @FumbleFingers: But "underperforming" is different from "performant", especially in the context of programming. I would be correct to say that "the application is underperforming", because "the code is not performant". The code itself cannot be underperforming, because that would suggest that the same code has varying degrees of performance (which it does not). "Performant" is an immutable trait (a specific code snippet definitively is or isn't performant), "underperforming" implies that the performance of the same code snippet can be changed (which is impossible).
    – Flater
    Commented Sep 28, 2017 at 11:17
  • As Mr. Shiny and New says here, and as pointed out by several people on the earlier question What is wrong with the word “performant”?, even among people who are happy to accept what's effectively a jargon neologism, there really isn't much of a consensus as regards exactly what it's supposed to mean. But many people specifically use it to mean performs well (not just "works"). I suggest it would be quite possible for a routine to work very well almost all the time, but to become "non-performant" only when processing very rare data. Commented Sep 28, 2017 at 12:29

I guess you could simply say inefficient code instead of unperformant.

  • 1
    Agreed, but only if by "performance" they mean "efficiency". Hence the questions in comments above.
    – Rupe
    Commented Jun 23, 2014 at 16:58
  • 2
    @Rupe is correct: efficiency is about benefit derived divided by total cost. Performance is related, but different. Performance is about identifying a particular cost and then ensuring that the program stays within its budget. For example: storing a million numbers that are always between 1 and 10 in 32 bit integers is inefficient in terms of memory cost per integer used, but may be highly performant in terms of parallelized operations per second due to proper alignment. Commented Jun 23, 2014 at 23:32
  • 1
    @Eric where is performant in a proper, official, English dictionary? Code can perform well (and can be described as such) without having to describe it using non-words. Commented Jun 23, 2014 at 23:54
  • @AaronBertrand: An official English dictionary? There is absolutely no such thing. There is no Academie Francaise equivalent in English, sorry. "Performant" is not a non-word; it's a perfectly cromulent word. Commented Jun 24, 2014 at 13:42
  • @AaronBertrand: And I looked up "word" in a "proper" English dictionary, and it said a single distinct meaningful element of speech or writing, not a single distinct meaningful element of speech or writing found in a proper official dictionary. Since "performant" is a single distinct meaningful element of speech or writing, and since you like words such as "word" to be defined in proper dictionaries, we must logically conclude that "performant" is a word, and not a non-word. Commented Jun 24, 2014 at 13:47

I'm a programmer. Here are the ways I would describe that kind of code:

  • The code has poor performance.
  • The code is slow. Or, the code runs slowly.
  • The code has high overhead. (You may specify time or memory overhead.)
  • The algorithm is needlessly expensive.
  • The code is not optimized for performance.
  • The code does not scale well.
  • Or how about "The code is not optimal".
    – ioquatix
    Commented Dec 15, 2015 at 22:02
  • 1
    How about, “The code is bad. It doesn't do well what it is supposed to do." Commented Aug 18, 2017 at 19:17
  • @ioquatix: "Optimal" is vague. It could be referring to maintainability, readability, ... Your suggestion only works if it's already implicitly understood that you're focusing on performance.
    – Flater
    Commented Sep 28, 2017 at 11:20
  • @Animadversor same as ioquatix, "bad" is vague. It could be referring to maintainability, readability, ... Your suggestion only works if it's already implicitly understood that you're focusing on performance.
    – Flater
    Commented Sep 28, 2017 at 11:21

I would argue that English speakers will generally be able to understand "unperformant". If we break the word apart.

Together unperformant basically means that X is the embodiment of not doing something (well).

The problem I see is the word relies on an unspecified and unqualified meaning of the word "perform". With my background I would interpret your statement

This kind of coding style leads to unmaintainable and unperformant code.

as meaning:

The way the developer is writing this piece of code makes it prohibitively expensive to maintain and the code is needlessly slow to execute.

  • Unmaintainable: prohibitively expensive (in terms of time/resources) to maintain.
  • Unperformant: needlessly slow (in terms of execution time)

That may or may not be your intention. Personally, when my code is performing well I think of it as executing quickly. This isn't always the case:

  • Data Modelers/Machine Learning people might think the predictions aren't good enough
  • Embeded developers, or other developers constrained by memory, might think the code is inefficient with memory.
  • Game developers might think the sprites are taking too long to render.
  • Security experts might think your password hash algorithm is too fast.
  • Cryptology developers might think your cipher is weak.
  • Developers trying to scale their work across machines/processors/cores may think it parallelizes poorly.
  • Machinists programming their CNC mill with M-codes might think the cuts are being made and/or ordered inefficiently.
  • A developer of a financial application might think that not enough significant digits are maintained.
  • Insert programming constraint here that isn't being respected.

Overall I think it is better to say what is "unperformant" about X or why X is "unperformant." That way the problem is clear, and you can side-step whether or not "unperformant" is a real word. In my opinion without context simply "unperformant" is too vague to be useful. Presumably you're trying to help the other person solve their problem, so it behooves you to frame the problem as clearly as possible.


According to OED, the word unperforming, first noted in the 17th century, is in current usage as

especially not performing well or to the current standard.

From a technical perspective, that's a near-perfect definition as it would be useable for design reviews (in response to a specification) as well as in business discussions. The composition seems like the word would be obvious even to one unfamiliar with it. For whatever reason, unperforming is not an entry in my OS X dictionary, but then neither is unperformant. Though it not be in popular American usage, it may be a better choice than coining a new word without providing a definition.


A naive implementation describes the simplest thing that could possibly work. It's not written with performance in mind, and if it happens to perform well that is entirely accidental.

Linear search ("look at each thing we've collected until we find the thing we are looking for") is the classic naive implementation when faced with the problem of "find this thing in the collection of things we know of".

  • 2
    But naive implementation does not necessarily mean it is slower or less efficient than a more mature implementation. Commented Jun 23, 2014 at 19:52
  • Even if it performs well enough it is still not written with performance in mind, which I understood to be the essence of the original question.
    – Jason M
    Commented Jun 23, 2014 at 22:09
  • 3
    But what I'm suggesting is that a naive implementation could have been written with performance in mind, that doesn't make it non-naive. Commented Jun 23, 2014 at 23:51
  • Some naive implementations actually do work really well though. Bubblesort no. Naive Bayes classifiers yes. Commented Sep 26, 2017 at 2:59
  • The 'naive' in naive implementation is not a slur. It just means that the implementation has no other consideration other than "it works".
    – Jason M
    Commented Sep 27, 2017 at 22:29

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.