State-of-the-Art Shitcode Principles

This a list of state-of-the-art shitcode principles your project should follow to call it a proper shitcode.

Read this in other languages: 简体中文

Get Your Badge

If your repository follows the state-of-the-art shitcode principles you may use the following "state-of-the-art shitcode" badge:

Markdown source-code for the 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

Less keystrokes, more time for you.

Good 👍🏻

let a = 42;

Bad 👎🏻

let age = 42;

💩 Mix variable/functions naming style

Celebrate the difference.

Good 👍🏻

let wWidth = 640;
let w_height = 480;

Bad 👎🏻

let windowWidth = 640;
let windowHeight = 480;

💩 Never write comments

No one is going to read your code anyway.

Good 👍🏻

const cdr = 700;

Bad 👎🏻

More often comments should contain some 'why' and not some 'what'. If the 'what' is not clear in the code, the code is probably too messy.

// 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

If you violated the "No comments" principle then at least try to write comments in a language that is different from the language you use to write the code. If your native language is English you may violate this principle.

Good 👍🏻

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

Bad 👎🏻

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

💩 Try to mix formatting style as much as possible

Celebrate the difference.

Good 👍🏻

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

Bad 👎🏻

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

💩 Put as much code as possible into one line

Good 👍🏻

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

Bad 👎🏻

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

💩 Fail silently

Whenever you catch an error it is not necessary for anyone to know about it. No logs, no error modals, chill.

Good 👍🏻

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

Bad 👎🏻

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

💩 Use global variables extensively

Globalization principle.

Good 👍🏻

let x = 5;

function square() {
  x = x ** 2;
}

square(); // Now x is 25.

Bad 👎🏻

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.

Just in case.

Good 👍🏻

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

Bad 👎🏻

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.

Good 👍🏻

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

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

Bad 👎🏻

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

This is your "Plan B".

Good 👍🏻

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

Bad 👎🏻

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

💩 Triangle principle

Be like a bird - nest, nest, nest.

Good 👍🏻

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

Bad 👎🏻

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

💩 Mess with indentations

Avoid indentations since they make complex code take up more space in the editor. If you're not feeling like avoiding them then just mess with them.

Good 👍🏻

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

Bad 👎🏻

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

Update your dependencies on each new installation in uncontrolled way. Why stick to the past, let's use the cutting edge libraries versions.

Good 👍🏻

$ ls -la

package.json

Bad 👎🏻

$ ls -la

package.json
package-lock.json

💩 Always name your boolean value a `flag`

Leave the space for your colleagues to think what the boolean value means.

Good 👍🏻

let flag = true;

Bad 👎🏻

let isDone = false;
let isEmpty = false;

💩 Long-read functions are better than short ones.

Don't divide a program logic into readable pieces. What if your IDE's search brakes and you will not be able to find the necessary file or function?

10000 lines of code in one file is OK.
1000 lines of a function body is OK.
Dealing with many services (3rd party and internal, also, there are some helpers, database hand-written ORM and jQuery slider) in one service.js? It's OK.

💩 Avoid covering your code with tests

This is a duplicate and unnecessary amount of work.

💩 As hard as you can try to avoid code linters

Write code as you want, especially if there is more than one developer in a team. This is a "freedom" principle.

💩 Start your project without a README file.

And keep it that way for the time being.

💩 You need to have unnecessary code

Don't delete the code your app doesn't use. At most, comment it.

Web Services Design

💩 Do not follow url hierarchy conventions

less thinking, more coding

Good 👍🏻

app.get('/e-workers', ()=>{})
app.get('/e-members', ()=>{})

Bad 👎🏻

app.get('/explore/workers', ()=>{})
app.get('/explore/members', ()=>{})

💩 Always Keep Your Code In One File

Keep your projects organized by coding all the project in a single file

Good 👍🏻

app.get('/',()=>{})
app.get('/foo',()=>{})
app.get('/bar',()=>{})
app.get('/users',()=>{})

Bad 👎🏻

import users from './routes/users';
app.use('users', users);

💩 Never use the PUT-DELETE-PATCH methods

Only experienced programmers know that you only need either GET or POST requests in your applications no need for the extra confusion

Good 👍🏻

app.post('/createUser/:id',()=>{})
app.post('/EditUserData/:id',()=>{})
app.post('/DeleteUser/:id',()=>{})

Bad 👎🏻

app.post('/user/:id',()=>{})
app.put('/user/:id',()=>{})
app.delete('/user/:id',()=>{})

💩 Always keep your endpoints names as short as you can

Less characters in your url names keeps your system permanence high

Good 👍🏻

app.get('/l',()=>{})
app.get('/s',()=>{})
app.get('/uv',()=>{})

Bad 👎🏻

app.get('/login',()=>{})
app.get('/signup',()=>{})
app.get('/user/validate',()=>{})

💩 You can always receive JSON in your GET requests

if you chose to handle all requests using GET requests instead of post then it's a good practice to receive JSON objects in a query parameter

Good 👍🏻

// get -> 127.0.0.1:3000/l?json={"app":"cool"}
app.get('/l', (req, res)=>{
    let json = req.params['json'];
    let jsonParsed  = JSON.parse(json);
})

Bad 👎🏻

app.post('/l', (req, res)=>{
    let json = req.body;
})

Ibrahimrahhal/state-of-the-art-shitcode

State-of-the-Art Shitcode Principles

Get Your Badge

The Principles

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

💩 Mix variable/functions naming style

💩 Never write comments

💩 Always write comments in your native language

💩 Try to mix formatting style as much as possible

💩 Put as much code as possible into one line

💩 Fail silently

💩 Use global variables extensively

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

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

💩 You need to have an unreachable piece of code

💩 Triangle principle

💩 Mess with indentations

💩 Do not lock your dependencies

💩 Always name your boolean value a flag

💩 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

Web Services Design

💩 Do not follow url hierarchy conventions

💩 Always Keep Your Code In One File

💩 Never use the PUT-DELETE-PATCH methods

💩 Always keep your endpoints names as short as you can

💩 You can always receive JSON in your GET requests

💩 Always name your boolean value a `flag`