State-of-the-Art Shitcode Principles

Get Your Badge

[![State-of-the-art Shitcode](https://img.shields.io/static/v1?label=State-of-the-art&message=Shitcode&color=7B5804)](https://github.com/trekhleb/state-of-the-art-shitcode)

The Principles

💩 Name variables in a way as if your code was already obfuscated

let a = 42;

let age = 42;

💩 Mix variable/functions naming style

let wWidth = 640;
let w_height = 480;

let windowWidth = 640;
let windowHeight = 480;

💩 Never write comments

const cdr = 700;

// The number of 700ms has been calculated empirically based on UX A/B test results.
// @see: <link to experiment or to related JIRA task or to something that explains number 700 in details>
const callbackDebounceRate = 700;

💩 Always write comments in your native language

// Закриваємо модальне віконечко при виникненні помилки.
toggleModal(false);

// Hide modal window on error.
toggleModal(false);

💩 Try to mix formatting style as much as possible

let i = ['tomato', 'onion', 'mushrooms'];
let d = [ "ketchup", "mayonnaise" ];

let ingredients = ['tomato', 'onion', 'mushrooms'];
let dressings = ['ketchup', 'mayonnaise'];

💩 Put as much code as possible into one line

document.location.search.replace(/(^\?)/,'').split('&').reduce(function(o,n){n=n.split('=');o[n[0]]=n[1];return o},{})

document.location.search
 .replace(/(^\?)/, '')
 .split('&')
 .reduce((searchParams, keyValuePair) => {
 keyValuePair = keyValuePair.split('=');
 searchParams[keyValuePair[0]] = keyValuePair[1];
 return searchParams;
 },
 {}
)

💩 Fail silently

try {
 // Something unpredictable.
} catch (error) {
 // tss... 🤫
}

try {
 // Something unpredictable.
} catch (error) {
 setErrorMessage(error.message);
 // and/or
 logError(error);
}

💩 Use global variables extensively

let x = 5;
function square() {
 x = x ** 2;
}
square(); // Now x is 25.

let x = 5;
function square(num) {
 return num ** 2;
}
x = square(x); // Now x is 25.

💩 Create variables that you're not going to use.

function sum(a, b, c) {
 const timeout = 1300;
 const result = a + b;
 return a + b;
}

function sum(a, b) {
 return a + b;
}

💩 Don't specify types and/or don't do type checks if language allows you to do so.

function sum(a, b) {
 return a + b;
}
// Having untyped fun here.
const guessWhat = sum([], {}); // -> "[object Object]"
const guessWhatAgain = sum({}, []); // -> 0

function sum(a: number, b: number): ?number {
 // Covering the case when we don't do transpilation and/or Flow type checks in JS.
 if (typeof a !== 'number' && typeof b !== 'number') {
 return undefined;
 }
 return a + b;
}
// This one should fail during the transpilation/compilation.
const guessWhat = sum([], {}); // -> undefined

💩 You need to have an unreachable piece of code

function square(num) {
 if (typeof num === 'undefined') {
 return undefined;
 }
 else {
 return num ** 2;
 }
 return null; // This is my "Plan B".
}

function square(num) {
 if (typeof num === 'undefined') {
 return undefined;
 }
 return num ** 2;
}

💩 Triangle principle

function someFunction() {
 if (condition1) {
 if (condition2) {
 asyncFunction(params, (result) => {
 if (result) {
 for (;;) {
 if (condition3) {
 }
 }
 }
 })
 }
 }
}

async function someFunction() {
 if (!condition1 || !condition2) {
 return;
 }
 
 const result = await asyncFunction(params);
 if (!result) {
 return;
 }
 
 for (;;) {
 if (condition3) {
 }
 }
}

💩 Mess with indentations

const fruits = ['apple',
 'orange', 'grape', 'pineapple'];
 const toppings = ['syrup', 'cream', 
 'jam', 
 'chocolate'];
const desserts = [];
fruits.forEach(fruit => {
toppings.forEach(topping => {
 desserts.push([
fruit,topping]);
 });})

const fruits = ['apple', 'orange', 'grape', 'pineapple'];
const toppings = ['syrup', 'cream', 'jam', 'chocolate'];
const desserts = [];
fruits.forEach(fruit => {
 toppings.forEach(topping => {
 desserts.push([fruit, topping]); 
 });
})

💩 Do not lock your dependencies

$ ls -la
package.json

$ ls -la
package.json
package-lock.json

💩 Always name your boolean value a flag

let flag = true;

let isDone = false;
let isEmpty = false;

💩 Long-read functions are better than short ones.

💩 Avoid covering your code with tests

💩 As hard as you can try to avoid code linters

💩 Start your project without a README file.

💩 You need to have unnecessary code