function getMonthName(monthNumber) {
const date = new Date();
date.setMonth(monthNumber - 1);
return date.toLocaleString([], { month: 'long' });
}
The difference is that hrowing an error makes it much easier to find the bug early, while doing the wrong thing silently makes it much harder to do so. If an error is thrown by the API then the first time wrong input is supply the application will fail and you’ll know you have a problem. If the API silently does the wrong thing, then the application will keep doing the wrong thing until somebody notices and that tends to be far more costly.
Finally, I’d like to note that this isn’t a hypothetical debate. This is how APIs work in sane languages such as Java:
java.time.LocalDate.of(2023, 2, 31)
> java.time.DateTimeException: Invalid date 'FEBRUARY 31'
java.time.LocalDate.of(2023, 2, 3)
> #object[java.time.LocalDate 0x2bc77260 "2023-02-03"]
Yes, and I’ve said that I agree with that in general. I know that this isn’t hypothetical; that’s exactly why I keep saying that throwing an error doesn’t help you find this bug early at all.
Even the silent weirdness can be caught by the most basic of tests checking output against input, but only if your function works the same way on every invocation.
Whether making a giant fuss (as you’d prefer) or making the best of it (as it actually does), the setMonth method always works the same way. My code always works the same way. The setDate suggestion makes the code always work the same way.
Code that always works the same way is easy to test.
If the day of the month is constant and incompatible with setMonth, whether there’s a thrown error or just an unwanted return value, a simple test will reveal that on every test run. If the day of the month is constant and always compatible with setMonth, the test will pass appropriately on every test run.
The bug in the code you originally presented comes from working differently over time. That’s why, most days, tests won’t identify the problem, even with a fussy, noisy API. Most testing days, the date will just happen to be compatible, and even the fussiest, noisiest API will carry on without any mention of the problem.
The reason the original code works differently over time has nothing to do with the silent, unexpected behaviour of setMonth. It’s entirely down to calling Date() without arguments, the entire point of which is to give different values over time. That call effectively introduces state that is not controlled by the function. And not bringing it under control is the real source of the bug.
Yes, absolutely, JavaScript sucks. Make F# the only supported web scripting language! But JavaScript’s suckiness is not the cause of this particular bug. JavaScript’s suckiness is not the reason this bug is hard to catch. The real problem lies in code that functions differently over time when it should (and could easily) be consistent. That’s what actually makes it hard to test.
Plenty of other languages and API design choices still allow code that functions that work differently over time, which is why, as justifiable as the complaints are in general, those factors are irrelevant for this particular bug. Write code that always works the same way and the problem goes away. That’s the real core of the issue.
Obviously, that’s easier said than done, and it’s irritating that neither loud errors nor most testing will help you in this regard, but that’s the way it is.
Whether making a giant fuss (as you’d prefer) or making the best of it (as it actually does), the setMonth method always works the same way. My code always works the same way. The setDate suggestion makes the code always work the same way.
You’re missing my point entirely here. Current behavior works in a SURPRISING way and SILENTLY produces an output that’s most likely to be unintended. Let me give you a concrete example of the problem here.
Let’s say you have a calendar app that shows the current day by default, and then there are buttons to go to next or previous month. To get the current day you’d have to call Date(), and then you’d have next and previous month functions that would work off the date you got. In Js world these functions will mostly work, but once in a while give users a wrong month silently.
The bug in the code you originally presented comes from working differently over time. That’s why, most days, tests won’t identify the problem, even with a fussy, noisy API. Most testing days, the date will just happen to be compatible, and even the fussiest, noisiest API will carry on without any mention of the problem.
That’s not the problem at all, and your whole line of argument here is frankly bizarre. There are plenty of use cases where you need to have functions that do something based on a current date. That means needing to get the date from the system without knowing what that date is up front by calling Date() without set arguments. This isn’t some anti pattern that you keep trying to make it out to be. There is absolutely nothing wrong with getting the current date.
I’m not missing your points, even as you change them. I’ve agreed that JS sucks. I’ve agreed that errors can be more helpful. I’m not trying to argue with you about that. What I have said, from the beginning, is that in the code you originally presented a behavioural change for setMonth will not help you find the problem any faster. Test failures for the wrong output occur just as often as test failures for errors, on exactly the same few days each year. The API change gives no advantage for the specific function this discussion started with in this regard. However, an approach that avoids inconsistency will, because in this particular instance, that is the real source of the problem. That is all.
In that context—the one you started with—it does not matter that there is often good reason to call Date() without arguments. The getMonthName function presented, effectively an array lookup, should produce the same output for any given input every time. It has no reason to engage in any behaviour that varies from day to day.
There is absolutely nothing wrong with getting the current date.
Bluntly, the code you presented fails precisely because it gets the current date where it should create a more specific one, and then fails to deal with that variation appropriately. You can keep distracting yourself with language design decisions, but that won’t help you avoid this particular type of problem in the future because that’s not where it is.
Getting the current date is often fine. In this specific instance, it is not. That is why the function doesn’t work. If you are missing that point, as much as I appreciate your enthusiasm in continuing the conversation, I will take the L (and the code that actually works) and move on.
