What is an antonym for "refactoring" with regards to programming?

Consider this definition of "refactoring" from Martin Fowler's book, Refactoring: Improving the Design of Existing Code:

Refactoring is the process of changing a software system in such a way that it does not alter the external behavior of the code yet improves its internal structure.

What is an antonym for this definition of refactoring? More specifically, how would one describe the process of worsening or deteriorating the internal structure of a software system?

Someone pointed out that refactoring is an intentional act, and that there probably isn't a word that describes intentionally making software worse. I am fine with an antonym that does not communicate intention.

Solution 1:

The idea that software degrades over time is known as software rot (or, slightly less specifically, "bit rot"). There are two main variations. The first is that software that is not being maintained gradually degrades over time as the environment around the software changes. For example, upgrading to a new version of an operating system might make an existing software package stop working.

However, I think you are referring to the second variation, active rot (sometimes referred to as "software entropy"). In this variation, changes to the software increase the complexity of the software and degrade its internal structure. Programmers sometimes refer to these kinds of changes as technical debt, especially when making changes that are expedient in the short term, but that you know -- even as you are making the change -- that you will need to pay for later.

Solution 2:

Refuctoring

The process of taking a well-designed piece of code and, through a series of small, reversible changes, making it completely unmaintainable by anyone except yourself.

Bit tongue in cheek, but as you mentioned in the original post, people don't (normally) intentionally make code worse!

Solution 3:

If we want a well-known word that appears in standard dictionaries, and already has a domain-specific definition which applies specifically to software, I would recommend you use obfuscating, which is defined in the software discipline as something like "the process of making code harder for humans to understand." This can be done simply by removing relevant comments, or by using 'hacks' (anti-patterns), or by exploiting numerous language gotchas.

Obfuscation is often applied to low-level languages to make machine-code harder to reverse-engineer, but it can also be done on higher-level code, often to secure someone's hegemony over a given section of code by making it unpleasant for other programmers to deal with, even if it is open-source or otherwise shared amongst a group of people.