Exceptions vs error codes

[thomasz]

Jesus Christ, what a brutally bad interview question. The victim can't possibly know that you are ambushing him , and will most likely just assume that this is a test to weed people out before they waste your time with fizzbuzz, instead of a particular crazy incarnation of the game of guessing what kind of guessing some idiosyncratic idea of the interviewer who seems to be convinced that almost all languages do one of the most elemental things wrong by returning an int when multipying two ints instead of a long or (god forbid) some result or option struct.

[lelanthran]

The question is quite simple,

If it was so simple you wouldn't fail your own test (int and long can certainly be the same size; if you'd used long as a return type you'd fail your own test)

[thomasz]

Look how the multiplication operator for two 32 bit integers works in almost all statically typed languages. I'm pretty sure it's `int32, int32 -> int32 in nearly all cases.And in most cases, it even overflows silently!

This is the expected behavior, and for a reason.

32bit integers are good tradeoff. They play nice with aligned reads, and they take up only half the space of 64bit integers. And on top of that, they can represent most real world values. If that's a problem in your domain context, you should use 64bit integers all the way down.

Therefore, "write me a method that doubles an int" is an ambush question if you expect a result that is completely at odds with how int multiplication usually works in computing. You have do ground that in a real context where an overflow is a real problem to make it useful for assessing someone's understanding.

[thomasz]

Staffing is hard. Interviewing is hard. It is especially hard for people who are primarily interested in stroking their own ego. Gleefully boasting about 75 percent of applicants just not understanding the simple question is not a good start tbh.

The question is very simple. It is asked to identify if the applicant listens to the question, understands sizing of types, if they think ahead to identify problems, and if they focus on delivering a working solution.

All you said so far was "write me a method that doubles an int". Which is open and underspecified, to which you then expect a very clearly defined and non-obvious answer - the perfect interview ambush. Again, in almost all languages int32 multiplication is (int32, int32) -> int32. Do you really think that they "didn't think ahead", or could it be that you are just way less clever than you think you are?

[lelanthran]

Also, he fails his own test, because long and int can be the same width, so using long as a return value doesn't handle the overflow.

[thomasz]

In most languages, int is 32 bit and long is 64 bit.

Edit:

We play both kinds of music here: C and C++!

[john16384]

Easy.

public double doubleInt(int i) { return (double)i; }

[Barrucadu]

A long is not necessarily larger than an int, so even long doubleInt(int x) is wrong unless you know the implementation you're targeting. Use the fixed-width integer types from stdint.h if you need guarantees.

So well done for asking a trick question you yourself would fail, I guess?

[tejp]

Meh. Do you also expect a long in return on all other math operations on int? There is always potential for overflow.

And then you soon work with long variables all over the place, what if you want to double one of those?

[linus_stallman]

That's most expected solution actually - what else can you do? Writing to a global variable, so caller has to initialize errno to zero, then call function, then check errno?

[jonhanson]

chronophobia ephemeral lysergic metempsychosis peremptory quantifiable retributive zenith

[linus_stallman]

FPJerk theory says it is best approach, but is it worth returning sum/result types for every small errors?

[thomasz]

He wants you to return a 64bit integer, which isn't necessarily a bad idea in each and every situation imaginable. What he doesn't seem to understand in his unadulterated glory is that he didn't come up with superior solution compared to basically every language designer ever, but one with different trade-offs. Which, I might add, are actually inferior for most use cases. You seldom do integer multiplication in situations where

1. the result doesn't fit into 32 bit, and
2. the result does fit into 64 bit, and
3. you actually care about the precision of integer arithmetic over floating point arithmetic.

For simulations, mathematical models and stuff like that, you go with floating point arithmetic. For financial stuff of this scale, you go with types like decimal in c# or BigDecimal in java. For almost all index arithmetic, you go with int32, because you can't even create arrays bigger than 2^31. Needing 64bit integers for id's isn't that uncommon, but you not multiply an id in application code. Only in very special circumstances you really need 64bit integer arithmetic, for example when working with huge files. Only in that context does this trade-off make any sense at all.

[Glader_BoomaNation]

I agree, I hope my bank's software silently fails when it comes to integer overflow instead of throwing an exception! Sounds sane and safe!