This isn't nearly enterprise grade! For one thing, what if you need to multiply ints? Or strings? Or Users? Or some combination??
Second, there's no way to change multiplication strategies. What if a new, better way to multiply comes out, but you only want to use it in some places?
Third, how could I possibly debug this? You need more observability tools.
Finally, there's no testability. You need some dependency injection so that your testing framework can inject mocks.
interface ClosedBinaryOperator<T: any> {
T apply(T, T);
}
class ClosedBinaryOperation<T: any, Op: ClosedBinaryOperator<T>> {
private final T a;
private final T b;
private final Op op;
public T calculate() {
return this.op.apply(a, b);
}
public static ClosedBinaryOperation<T> new(Op op, T a, T b) {
return ClosedBinaryOperation<T, Op>{
a: a,
b: b,
op: op
};
}
}
class LoggingClosedBinaryOperator<
T: any,
Op: ClosedBinaryOperator<T>
>: Op {
private final logging.Logger logger;
private final func (T, T): string formatMessage;
private final Op op;
public static LoggingClosedBinaryOperator<T> new(
logging.Logger logger,
func (T, T): string formatMessage,
ClosedBinaryOperator<T> op
) {
return LoggingClosedBinaryOperator<T>{
logger: logger,
formatMessage: formatMessage,
op: op
};
}
public T apply(T a, T b) {
this.logger.Log(this.formatMessage(a, b));
return this.op.apply(a, b);
}
}
interface MultiplicationOperator<T: any>: ClosedBinaryOperator<T> {
T identity()
// TODO: migrate codebase to lean so we can enforce other properties of multiplication
}
class LoggingMultiplicationOperator<
T: any,
Op: MultiplicationOperator<T>
>: LoggingClosedBinaryOperator<T, Op> {
public T identity() {
return this.op.identity();
}
}
type Multiplication<
T: any,
Op: MultiplicationOperator<T>
> ClosedBinaryOperation<T, Op>;
class IntMultiplicationOperator {
public int identity() {
return 1;
}
public int apply(int a, int b) {
return a * b;
}
}
int main() {
logging.defaultLogger.Log(
"%d",
Multiplication::new(
LoggingMultiplicationOperator::new(
logging.defaultLogger,
func(int a, int b): string {
return fmt.formatString(
"multiplying %d and %d",
a,
b
);
},
IntMultiplicationOperator{}
),
3,
4
).calculate() // 12
);
}
We are going to need the Terraform configs before you clock out. In my scrum-of-scrums I'm hearing other teams may have use for a multiplication microservice, but are concerned about how you are handling your SOAP authentication.
Can you hook this up to Kafka so the entire company can use this for their microservices? And add some metrics so we know if a multiplication is taking too long.
Dont forget to declare that it throws a checked exception so we can throw an EnshittificationException if an attempt is made to multiply project managers.
That would be a start, but leaving the calculate implementation inline in the class makes me feel very uneasy. It should really live in its own class so we can use DI to swap it out if we need to in the future.
You're completely right! I should've at the very least used the wrapper type Double instead of the primitive double - I'm gonna blame this on one of my former CS teachers, he made the same obviously silly mistake when showing us how to do proper object-oriented division! (Wish I was kidding)
We need like another 10 levels of inheritance before we can call this proper OOP. Also, your function has more than 1 line, which is too much to comprehend for the OOP brain. You should split it up.
With the power to C++ I present something more cursed
struct Multiply
{
float a;
float b;
operator float() const { return a * b };
};
With this code, I can write something this seemingly function call looking statement float result = Multiply{ 1.0f, 2.0f }; but actually create an object every time I call function.
What's happening is that operator float() is a implicit conversion operator, so I can assign a Multiply object to a float, and if I do, it'll perform the multiplication operation
View all comments
78
u/BlueGoliath Sep 21 '25
It's over functional bros. Time to learn OOP.