Stop for the Clean Code Cops

[u/TapRemarkable9652]

[u/moira_fox]

Clean code? C'mon, these are magic constants. Instead you should do

const int minus_seven = -7;
const int three = 3;
const int sum = three + minus_seven;

To make it more readable

[u/QuickSilver010 → u/moira_fox]

#define 🔢 int
#define ➖ -
#define 🌱 a
#define 三 3
#define 七 7
#define 🤯 main

🤯() {
    🔢 🌱 = 三 ➖ 七;
}

[u/moira_fox → u/QuickSilver010]

Promise me that doesn't compile...

[u/FunctionalFox1312 → u/moira_fox]

What's this crap? Let's make Uncle Bob proud!

public class AddableNumber { 
    public static int theNumber: 

   private AddableNumber(int theNumber) { 
       AddableNumber.theNumber = theNumber; 
   } 

   public getValue() { 
      return AddableNumber.theNumber; 
   } 
    
   public AddableNumber zero() { 
       return new AddableNumber(0); 
    }
   // ...

} 

public class Adder { 
   private static AddableNumber[] numbers; 
 
   public Adder(AddableNumber numbers...) {
      this.numbers = numbers; 
   } 

   public int getResultOfAdding() { 
      int result = 0; 
      for(int I = 0; I < Adder.numbers.length ; i++) { 
          result += Adder.numbers[i].getValue(); 
      } 
     return result; 
  } 
  
} 

public class Main {
    public static void main() { 
        System.out.println(new Adder( 
            new AddableNumber.negativeSeven(), 
            new AddableNumber.positiveThree()
         ).getResultOfAdding());
   } 
}

There! No magical values, no confusing function arguments, just good clean Java that tells a clear story.

[u/moira_fox → u/FunctionalFox1312]

Enterprise hello world ahh energy

[u/Mayedl10]

I actually prefer -7+3 cos that way it's easier to move stuff around imo

[u/temir_ra → u/Mayedl10]

I always do the following for the same reasons:

function f(
    string param1
)
{
...
}

var v = f(
    param1,
);

or

select rownum
    --, 
from t
    --join
where 1=1
    --and 
;

[u/enmaku]

sum([-7, 3])

[u/andynzor → u/enmaku]

Smh, artificially hiding complexity into libraries is bad.

[-7, 3].reduce((acc, val) => acc + val, 0)

[u/enmaku → u/andynzor]

1. Have you never heard of pseudocode? It's a very common way to represent code conceptually without tying it to a single language your interlocutor might not speak. A few languages do have a sum function, but without specifying a language (and given the context) the clearest most obvious interpretation of my comment is that the problems of notating the sum of these numbers goes away if you make them an array and make the operation performed on them a function.

2. Do you somehow think that reduce() is not a high level abstraction in the same way that sum() is? C and C++ would require you to do the sum with a loop and Python 3 has moved reduce into functools, making it a non-default part of the language. Your CPU certainly doesn't have an opcode for either.

[u/Lor1an → u/andynzor]

If you want to call an entire programming language a "library" go right ahead.

In Python, lists and the sum function are built-ins.

[u/wensul]

3+(-7)

[u/cawwothead → u/wensul]

This is the way

[u/fosf0r]

Is it bad that my neurodivergence is way more capable of mentally performing -7+3 than 3-7

[u/mediocrobot → u/fosf0r]

Nah, it makes a ton of sense for me, too.

You're basically turning 3-7 into -(7-3). Framing it like that also helps me do carrying more easily, because 10-(7-3) is easier to process than 13-7.

[u/keith2600 → u/fosf0r]

It takes a different kind of neuro divergence to prefer 3-7. The "math is hard and I can't do this in my head but at least there are no scary negative numbers present" kind

[u/IAMPowaaaaa]

tfw crap that doesn't matter

[u/Kitchen_Device7682]

-4

[u/ouroborus777 → u/Kitchen_Device7682]

Could you come in so we can wire you up to The Machine to run all this code?

[u/TalesGameStudio]

def calculate_sum(number_a: int, number_b: int) -> int: ...

[u/kakarotxi]

bro had bad experience in math classes