Oh JavaScript, you silly goose.
-
No; keeping the application from crashing is the application developer's job, not the language or library developer's job.
I take you don't do much hardcore JavaScript development. I'd rather check for values than have the entire web page stop working with no way to recover because the engine went bye bye.
Jeremy Falcon
-
Jeremy Falcon wrote:
I'm a very defensive programmer so I'd always validate my inputs
And you wonder why you are just now finding out the divide by zero handling in JS :laugh: .
Never underestimate the power of human stupidity RAH
Good point.
Jeremy Falcon
-
I take you don't do much hardcore JavaScript development. I'd rather check for values than have the entire web page stop working with no way to recover because the engine went bye bye.
Jeremy Falcon
I don't do any of that Web crap; I do real software development.
-
I don't do any of that Web crap; I do real software development.
Would you like a lollipop?
Jeremy Falcon
-
You didn't know about NaN yet? Or infinity? Or that JS uses elephanting floats all over the place? It gets better, 1/0 is positive infinity but 1/-0 is negative infinity, even though 0 and -0 compare equal to each other.
That positive 0 and negative 0, of course has nothing to do with JS... It comes from the IEEE 754 standard, and you can find it in C# implementation too... Exception handling is very expensive in terms of computer resources, so we already used to validate user input...In this case JS follows to the letter the standard... https://en.wikipedia.org/wiki/IEEE_floating_point[^]
Skipper: We'll fix it. Alex: Fix it? How you gonna fix this? Skipper: Grit, spit and a whole lotta duct tape.
-
After years and years of using JavaScript, only now do I find that checking for zero on the denominator when dividing is a complete waste of time since JavaScript handles it gracefully without crashing.
console.log(0 / 0); // returns NaN
console.log(1 / 0); // returns Infinity// let's get fancy
var divide = (...args) => args.reduce((a, b) => a / b);console.log(divide(0, 0)); // still returns NaN
console.log(divide(1, 0)); // still returns Infinity// if I want to save the sucker in a database
var result = divide(42, 0);
saveMeSomehow.result = isNaN(result) || !isFinite(result) ? 0 : result;These young kids these days just don't know how spoiled they are. Note: I don't think the syntax highlighting supports ES6 yet, so yay I broke the Internet.
Jeremy Falcon
-
That positive 0 and negative 0, of course has nothing to do with JS... It comes from the IEEE 754 standard, and you can find it in C# implementation too... Exception handling is very expensive in terms of computer resources, so we already used to validate user input...In this case JS follows to the letter the standard... https://en.wikipedia.org/wiki/IEEE_floating_point[^]
Skipper: We'll fix it. Alex: Fix it? How you gonna fix this? Skipper: Grit, spit and a whole lotta duct tape.
-
After years and years of using JavaScript, only now do I find that checking for zero on the denominator when dividing is a complete waste of time since JavaScript handles it gracefully without crashing.
console.log(0 / 0); // returns NaN
console.log(1 / 0); // returns Infinity// let's get fancy
var divide = (...args) => args.reduce((a, b) => a / b);console.log(divide(0, 0)); // still returns NaN
console.log(divide(1, 0)); // still returns Infinity// if I want to save the sucker in a database
var result = divide(42, 0);
saveMeSomehow.result = isNaN(result) || !isFinite(result) ? 0 : result;These young kids these days just don't know how spoiled they are. Note: I don't think the syntax highlighting supports ES6 yet, so yay I broke the Internet.
Jeremy Falcon
I'm glad my college math professor doesn't program in JavaScript, he'd have a fit seeing a variable equal to infinity. Nothing is ever equal to infinity because it isn't a single number. The result of an equation tends to infinity when a certain condition becomes true (I suck at math so I don't think any explanation would make much sense) In the divide by zero example, the limit of x/n as n tends to zero is infinity.
-
After years and years of using JavaScript, only now do I find that checking for zero on the denominator when dividing is a complete waste of time since JavaScript handles it gracefully without crashing.
console.log(0 / 0); // returns NaN
console.log(1 / 0); // returns Infinity// let's get fancy
var divide = (...args) => args.reduce((a, b) => a / b);console.log(divide(0, 0)); // still returns NaN
console.log(divide(1, 0)); // still returns Infinity// if I want to save the sucker in a database
var result = divide(42, 0);
saveMeSomehow.result = isNaN(result) || !isFinite(result) ? 0 : result;These young kids these days just don't know how spoiled they are. Note: I don't think the syntax highlighting supports ES6 yet, so yay I broke the Internet.
Jeremy Falcon
:beer:
veni bibi saltavi
-
:beer:
veni bibi saltavi
Thanks man! Cheers.
Jeremy Falcon
-
Ok, but I must admit that I still do not like it. This way you always have to test the results which bloats up the code. First, it's an avoidable error and, assuming it comes to my attention, I will find out why the denominater can become zero and then eliminate the problem once and for all. So what's won by bravely keeping going until the error manifests itself somplace else? You will just have to spend more time tracing it back to its origin and then essentially doing the same work to correct it.
The language is JavaScript. that of Mordor, which I will not utter here
This is Javascript. If you put big wheels and a racing stripe on a golf cart, it's still a fucking golf cart.
"I don't know, extraterrestrial?" "You mean like from space?" "No, from Canada." If software development were a circus, we would all be the clowns.But if it didn't do this you would just always have to test the inputs instead to ensure the application doesn't throw an error, which isn't necessarily any better. Besides, it's possible you may not have to test the results anyway, if you aren't relying on them being a number, e.g. in the below code it doesn't matter if b is 0:
if(a / b === 0.25){ ... }
-
No; keeping the application from crashing is the application developer's job, not the language or library developer's job.
PIEBALDconsult wrote:
keeping the application from crashing is the application developer's job
The language shouldn't crash the application unnecessarily, though. The result of a division operation isn't necessarily useless or invalid just because the divisor was 0. If you want to test that
x/y === 10then whenyequals 0 you probably just want afalseresult, not an unhandled exception. This behaviour means that you only have to put in special-case handling fory === 0if you need it. At the same time, if your use case does require it but you forget to put it in, then you'll probably get the error thrown anyway when you handle the result of the division, rather than the bug being masked. -
But if it didn't do this you would just always have to test the inputs instead to ensure the application doesn't throw an error, which isn't necessarily any better. Besides, it's possible you may not have to test the results anyway, if you aren't relying on them being a number, e.g. in the below code it doesn't matter if b is 0:
if(a / b === 0.25){ ... }
Benito Aramando wrote:
But if it didn't do this you would just always have to test the inputs instead to ensure the application doesn't throw an error, which isn't necessarily any better.
Let's assume a very common case in C#: A reference is null and an exeption will be thrown if the program tries to use the reference. If this can be corrected, then testing beforehand and performing this correction is the way to go. If not, then what could I possibly accomplish by testing? I simply let the exeption fly, let it end up in some Pokemon exception handler and will get to read about it in the log. After that I will check the conditions that led to the error and will never have to worry about it ever again. Avoidable errors should indeed be avoided, not handled (gracefully or not) or tested. They are like sand in your gears. I want them to come to my attention and getting rid of them once and for all is worth the time and the work.
The language is JavaScript. that of Mordor, which I will not utter here
This is Javascript. If you put big wheels and a racing stripe on a golf cart, it's still a fucking golf cart.
"I don't know, extraterrestrial?" "You mean like from space?" "No, from Canada." If software development were a circus, we would all be the clowns. -
Benito Aramando wrote:
But if it didn't do this you would just always have to test the inputs instead to ensure the application doesn't throw an error, which isn't necessarily any better.
Let's assume a very common case in C#: A reference is null and an exeption will be thrown if the program tries to use the reference. If this can be corrected, then testing beforehand and performing this correction is the way to go. If not, then what could I possibly accomplish by testing? I simply let the exeption fly, let it end up in some Pokemon exception handler and will get to read about it in the log. After that I will check the conditions that led to the error and will never have to worry about it ever again. Avoidable errors should indeed be avoided, not handled (gracefully or not) or tested. They are like sand in your gears. I want them to come to my attention and getting rid of them once and for all is worth the time and the work.
The language is JavaScript. that of Mordor, which I will not utter here
This is Javascript. If you put big wheels and a racing stripe on a golf cart, it's still a fucking golf cart.
"I don't know, extraterrestrial?" "You mean like from space?" "No, from Canada." If software development were a circus, we would all be the clowns.I should have put my statements the other way around. Your response to the one you quoted is fair enough, but your point is predicated on the assumption that the result of a division by 0 must always represent an error that should have been avoided before that point. This isn't necessarily the case.
-
I should have put my statements the other way around. Your response to the one you quoted is fair enough, but your point is predicated on the assumption that the result of a division by 0 must always represent an error that should have been avoided before that point. This isn't necessarily the case.
Most of the time it is, so if the exception comes and it is not, you know what to do to meet this precondition. The other way around some real errors may go unnoticed for a long time, plus the extra effort for tracing it back to its origin.
The language is JavaScript. that of Mordor, which I will not utter here
This is Javascript. If you put big wheels and a racing stripe on a golf cart, it's still a fucking golf cart.
"I don't know, extraterrestrial?" "You mean like from space?" "No, from Canada." If software development were a circus, we would all be the clowns. -
After years and years of using JavaScript, only now do I find that checking for zero on the denominator when dividing is a complete waste of time since JavaScript handles it gracefully without crashing.
console.log(0 / 0); // returns NaN
console.log(1 / 0); // returns Infinity// let's get fancy
var divide = (...args) => args.reduce((a, b) => a / b);console.log(divide(0, 0)); // still returns NaN
console.log(divide(1, 0)); // still returns Infinity// if I want to save the sucker in a database
var result = divide(42, 0);
saveMeSomehow.result = isNaN(result) || !isFinite(result) ? 0 : result;These young kids these days just don't know how spoiled they are. Note: I don't think the syntax highlighting supports ES6 yet, so yay I broke the Internet.
Jeremy Falcon
.NET does exactly the same thing with floating-point arithmetic. AFAIK, so does Java. The behaviour is required by IEEE-754[^]:
IEEE-754 : Frequently Asked Questions : Why doesn't division by zero (or overflow, or underflow) stop the program or trigger an error?[^]
The 754 model encourages robust programs. It is intended not only for numerical analysts but also for spreadsheet users, database systems, or even coffee pots. The propagation rules for NaNs and infinities allow inconsequential exceptions to vanish. Similarly, gradual underflow maintains error properties over a precision's range.
"These people looked deep within my soul and assigned me a number based on the order in which I joined." - Homer
-
.NET does exactly the same thing with floating-point arithmetic. AFAIK, so does Java. The behaviour is required by IEEE-754[^]:
IEEE-754 : Frequently Asked Questions : Why doesn't division by zero (or overflow, or underflow) stop the program or trigger an error?[^]
The 754 model encourages robust programs. It is intended not only for numerical analysts but also for spreadsheet users, database systems, or even coffee pots. The propagation rules for NaNs and infinities allow inconsequential exceptions to vanish. Similarly, gradual underflow maintains error properties over a precision's range.
"These people looked deep within my soul and assigned me a number based on the order in which I joined." - Homer
I never knew that. Thanks.
Jeremy Falcon
-
PIEBALDconsult wrote:
keeping the application from crashing is the application developer's job
The language shouldn't crash the application unnecessarily, though. The result of a division operation isn't necessarily useless or invalid just because the divisor was 0. If you want to test that
x/y === 10then whenyequals 0 you probably just want afalseresult, not an unhandled exception. This behaviour means that you only have to put in special-case handling fory === 0if you need it. At the same time, if your use case does require it but you forget to put it in, then you'll probably get the error thrown anyway when you handle the result of the division, rather than the bug being masked.Exactly. Having a system crash over an operation like that is not the right solution. In a second and third generation language I can see having a fault since everything has a fault so it's just how it's done, but most certainly not in a fourth generation language.
Jeremy Falcon
-
Most of the time it is, so if the exception comes and it is not, you know what to do to meet this precondition. The other way around some real errors may go unnoticed for a long time, plus the extra effort for tracing it back to its origin.
The language is JavaScript. that of Mordor, which I will not utter here
This is Javascript. If you put big wheels and a racing stripe on a golf cart, it's still a fucking golf cart.
"I don't know, extraterrestrial?" "You mean like from space?" "No, from Canada." If software development were a circus, we would all be the clowns.JavaScript still throws errors for a lot of things, but it and many other fourth generation languages (so I've been told) have decided to do something about dividing by zero being worthy of an "error". I happen to agree it's not an error, since infinity is a valid concept.
Jeremy Falcon
-
PIEBALDconsult wrote:
keeping the application from crashing is the application developer's job
The language shouldn't crash the application unnecessarily, though. The result of a division operation isn't necessarily useless or invalid just because the divisor was 0. If you want to test that
x/y === 10then whenyequals 0 you probably just want afalseresult, not an unhandled exception. This behaviour means that you only have to put in special-case handling fory === 0if you need it. At the same time, if your use case does require it but you forget to put it in, then you'll probably get the error thrown anyway when you handle the result of the division, rather than the bug being masked.I prefer the application to crash, because if the application doesn't crash in a /0, the programmer needs to know what to do in the case we get a division with 0 without exception, call it division by zero handling.... this then is for Advanced programmers, I can see a lot of code running and doing stuff and crashing some lines after the /0 where the programmer is in a different context, and will have hard time to understand the the issue is a /0 that was not handled 10 lines before... Then yes I prefer it to blow up in front of my face, a /0 exception is always easier to track. Think on null validations, you had learned to do Null validations because a null crash so ugly that you want to avoid it... I had seen code where a null was not validated (the -> expressions make it so easy to crash due bad null validations) and the code crash 100 lines after that missed validation. So, I'm not telling is bad or good, just I think it's for advanced programmers, the ones that already learned the price of a division by zero
