What if I prefer +=1 instead of ++ ?

variable = variable + 1;

Python won't hate you

var incrementor = 1;

newVariable = oldVariable + incrementor;

@DeSaboteur get an avatar, you have the required 10 points.

@DeSaboteur You made your incrementor a var. Thus, you're missing the incrementor's incrementor.

Otherwise... I bet const is a better fit for this.

OCaml dev would prefer incr

@DjSall Will do that right away! :D

AirBnB ESLint preset actually prefers +=1 too

Make a group about how real programmers use +=1 and everyone else is shit. That's what personal preferences are for.

LD A, YOURPREFERENCE
INC A

const int one = 1;
int increment = increment + one;

@Tobyvw he is a js developer probably.

var -= -1

// some sort of PHP/JS pseudo-code (sorry!)

class Increment () {
public function __constructor(int nb) {
this.increment = nb;
}

public function increment(int nb) : int {
return nb + this.increment;
}
}

var increment = new Increment(1);
echo increment.increment(1);

Should be efficient. Could add some getters and setters and make increment () private

🤤

It could make a difference when looking at it from an assembly point of view. Some architecture types have dedicated instructions for `++i` and `i++` so in these kind of situations you'd need one instructions, while `i += 1` actually is a register load, add immediate, register store. However a compiler will sort that out for you so don't worry (:

Tjat's the power of abstraction. Use what ever you feel like!

temp = 1
while (temp != 0) {
carry = variable & temp
variable = variable ^ temp
temp = carry << 1
}

Because arithmetic operators are for noobs

I agree with you, take my +=1 !

Ruby?

I also happen to prefer += 1.

Then u r using python

What about:
variable = variable + (variable / variable);
(?)

@Archer04
What about:
0
?

😂😂😂

@rhein7 or may be
variable = variable + (variable % (variable -1));

var foo = 1;
foo = foo + +true;

Its simple. You will get to put a rant and some x+=1 ++'s.

You guys just multiplied by two my ++s thanks 😘

@Emacs you mean shifted left by one :P

@Emacs < @Vim

@Archer04 does @Vim even exists ??

@Emacs nope, you should create it and use it as and alter-ego account :p

All you guys are doing it wrong!

var varObject = {
var1: 0
}

function incrByOne(varName){
varObject.varName = varObject.varName × 1;
}

IncrByOne("var1");

//obvs sarcasm

Actually, I'm kind of worried that nobody suggested a TAS or CAS with an atomic integer. What if you run your program using multiple threads?

fun add(a:Int) : (Int) -> Int {
return { b: Int -> a + b }
}
val addOne = add(-1*-1*-1*-1*-1*-1*-1*-1)
x = addOne(x)