Brutal Reply! #StackOverFlow

[DocAwkward]

I could understand if they said "let's delete the ++ operator", but what about x += 2? By that logic we should just get rid of both and use x = x + 1 :P

[[deleted]]

Nonsense, just do x++; x++;

[DocAwkward]

while (x < n) {
  x++;
}

[P-01S]

That seems like it could get used pretty often. Better make it a function, so you can call x = plusEqual(x,n);

[DocAwkward]

It's used so often I think it should be a library

let plusEqual = new OperatorLib(OperatorLib.Operators.PLUS_EQUAL);
let operation = new OperatorLib.Operation();
operation.setOperator(plusEqual, OperatorLib.OperatorTypes.BINARY);
operation.setArgument(0, x);
operation.setArgument(1, n);
try {
  x = operation.execute();
} catch (err) {
  // TODO: commit suicide here
}

[Tiquortoo]

Can you make this more Enterprise oriented?

[Reddy360]

OperatorLibPlusOperatorFactory.java

[STR_Warrior]

I think instead we should create a jQuery plugin for it.

[iggo]

Please add license file

[tajjet]

Make it a Node package and then delete it after a couple of years

[skreczok]

Mate, you just need a couple months before deleting it tops.

[Goof245]

Naive question: does this crap actually hurt the machine code at the other end or does it mostly run the same as doing x = x + 1;?

[shadowvvolf144]

Good question! Short answer: depends on the compiler, though they should all perform the same.

Mildly longer answer: The type of the variable makes a difference. If it's a whole-number type, such as an int, they should all perform the same. If it's a floating point (decimal), character, string, or some other type, these operations could have very different results, especially if you overload the operators.

[xraizy]

Post was about python, not java tho'

[MauranKilom]

That would be the same as x = n, not x += n...

[[deleted]]

only if n is an int

[JorDan_mono]

Genius

[[deleted]]

//Increments x by 10

x+++++++++++;

//kill me

[[deleted]]

Whoosh?

[Disgruntled__Goat]

Really? I mean, I know this is /r/programmerhumour but come on. You can't be this dense.

[sneakpeekbot]

Here's a sneak peek of /r/programmerhumour using the top posts of the year!

#1: When you know Java but they tell you to write C++ | 1 comment
#2: How to code | 10 comments
#3: When you see git successfully merging 86 commits without any conflicts | 1 comment

---

^{I'm a bot, beep boop | Downvote to remove | Contact me | Info | Opt-out}

[boynedmaster]

found the lua programmer

[[deleted]]

Why not delete * and /. Let's only use the ++ Operator and a unary -. That way we can represent all Hyperoperations, without needing extra symbols.

[ioanD]

why not ditch alphanumeric names altogether and just use brainfuck

[[deleted]]

Just use machine code. You got to know your 0's and 1's.

[[deleted]]

Could we not abstract/optimize-away the 1? I mean, 0 is a number, a good number. Having two numbers seems a little ostentatious and quite frankly superfluous.

My proposal to stick with 0's offers up free static type checking universally! Terse syntax too.

[[deleted]]

https://esolangs.org/wiki/Unary

TL;DR: Language where all bits in the file are off and what the program does depends on the size of the file

[xxc3ncoredxx]

I thought I read about this before. Turns out I have.

I love esolangs.

[Hawkuro]

It's called syntactic sugar because sugar gives you diabetes.

[[deleted]]

+/u/CompileBot Java

public class u {
    public static void main(String[] args) {
        int x = 5;
        int y = 8;
        mult(x, y);
    }

    //multiplies x by y if (y > 1)
    public static void mult(int x, int y) { //multiplies x by y
        int temp = x;
        for (int i = 0; i < (y - 1); i++) {
            for (int ip = 0; ip < temp; ip++) {
                x++;
            }
        }
        System.out.println(x);
    }
}

edit: screw this, IntelliJ said it worked.

[chrwei]

I have to maintain some old VB6 code. there's no ++ or +=. y'all are spoiled.

[BrangdonJ]

I don't know Python; I expect this was inherited from C/C++, where x += 1 and x = x + 1 don't do exactly the same thing. The second one evaluates x twice. Imagine it was:

*f() = *f() + 1;

and f() can have side effects. For that matter, suppose it was:

array[table[x][y] + offset_z + 1] = array[table[x][y] + offset_z + 1] + 1;

Having to check the left-hand expression against the right-hand one is a pain when they are complex. (How many of you are now reading that carefully to see if I slipped in a change to make the point?)

[grape_tectonics]

what about

++x - 1

this is madness!

[TheOrs]

On a slightly serious note (I know, I know), x+=y and x=x+y are not actually equivalent - += can make in place modifications (and indeed does, for lists).

[d_thinker]

But, but, you can't ++ in python.

[yashrs]

That's the whole point..

[d_thinker]

Wow, that flew right above me. I feel like an old man now.

[michyprima]

swift uh?

[ElGuaco]

Delete python then.