
GitHub search for 84600 seconds. Oops. - jeremycole
https://github.com/search?q=84600+seconds&type=Code
======
Steuard
Honestly, I think there's a little something to this submission beyond the "Ha
ha, lots of people made typos that could cause big problems" factor.

A public repository like GitHub makes checks for common errors like this
_really easy_. Would it be feasible for GitHub or the community to
automatically recognize broad classes of these likely errors and notify the
authors? How sophisticated could that sort of tool become?

Maybe "given enough bots, most bugs are shallow".

~~~
joshstrange
I agree, it's too bad they banned bots [0], one alternative I see is:

>> Yeah, maybe the answer is a hybrid, bots that look for common mistakes and
a website that lets people login to github and displays the potential fixes so
they can fix the code in the browser and send the pull request. Like a way to
try and introduce people to open source through guided fixes more or less. [1]

[0] [http://www.wired.com/2012/12/github-
bots/](http://www.wired.com/2012/12/github-bots/)

[1]
[https://news.ycombinator.com/item?id=7717694](https://news.ycombinator.com/item?id=7717694)

------
joshstrange
I wonder if Github will ever reconsider allowing bots [0]. There are bunch of
things like this that would be cool to have pull-requests automatically
generated for. Security fixes would be another place where I can see bots
helping to fix common mistakes.

[0] [http://www.wired.com/2012/12/github-
bots/](http://www.wired.com/2012/12/github-bots/)

~~~
XaspR8d
Yeah, I'd love to help in some way, but the number of results is huge and
without bots I'm discouraged from doing anything manually.

Maybe we can create a resource of common typos in numerical constants that
would auto-detect by edit distance? But I suppose most people willing to check
a resource like that probably already double check their arithmetic. (That
said, I've probably had this exact bug somewhere in my coding history, so no
shame.)

~~~
joshstrange
Yeah, maybe the answer is a hybrid, bots that look for common mistakes and a
website that lets people login to github and displays the potential fixes so
they can fix the code in the browser and send the pull request. Like a way to
try and introduce people to open source through guided fixes more or less.

------
memnips
86400 seconds is 24 hours. It is surprisingly commonly mis-entered as 84600
seconds, as evidenced by this search. As such, many unintended consequences
can ensue.

------
chubot
Haha, should be 86400, not 84600.

~~~
baddox
I liked this one:

    
    
        SECONDS_PER_23_5_HOURS = 84600

~~~
markcarlson
That is a very common value to use when you want something to either occur a
bit more than once a day, or time out in a bit less than a day.

~~~
underyx
And to keep the discussion interesting, also, 12 seconds is a pretty popular
timespan to use when you want something longer than 10, but shorter than 15.

------
Xylakant
It's actually not that many places where it's wrong: Anything from page 57 to
100 is one repo that does it consistently wrong:
[https://github.com/sconklin/solardata](https://github.com/sconklin/solardata),
then there's quite a few places that are partial matches only (seconds, but
not 84600), there's quite a few places where it's a least not obviously wrong
(page 38, where it matches on "PHI( 1) +6.18900e+05-7.84600e+05i Hz") and a
ton of places that get copied around (the first pages are all bundled versions
of the sonata cache interface).

------
nkozyra
Disturbing enough that - despite having used 86400 a bazillion times (yes,
literally) that it didn't look wrong at first glance.

------
markcarlson
Many of those are legitimately meant to be 23.5 hours, not 24 hours (TTL
defaults, approximates for converting seconds to days, etc.)

------
elwell
I don't think it's right to judge someone just because they have 23.5 hour
days. To each their own, I say.

------
akerl_
Humorous as this is, it doesn't seem newsworthy. Maybe submit to The Daily WTF
next time?

------
elwell
And none of them have any Stars:
[https://github.com/search?q=84600+seconds+stars%3A%3E0&type=...](https://github.com/search?q=84600+seconds+stars%3A%3E0&type=Repositories&ref=advsearch&l=)

------
nicklovescode
[https://github.com/search?q=%22%3D+funtion%28%29%22&type=Cod...](https://github.com/search?q=%22%3D+funtion%28%29%22&type=Code&ref=searchresults)

------
strommen
HN Challenge: name a scenario in which defining a constant as 86400 is better
then defining it as (60 * 60 * 24).

Or, are there languages where you can't declare a constant with a
multiplication expression?

~~~
zemo
> are there languages where you can't declare a constant with a multiplication
> expression?

obviously PHP.

    
    
      php > const X = 1;
      php > echo X;
      1
      php > const Y = 1 * 2;
    
      Parse error: parse error, expecting `','' or `';'' in php shell code on line 1
      php > echo Y;
      Y

~~~
mappu
Fixed in the (upcoming) PHP 5.6.

[https://wiki.php.net/rfc/const_scalar_exprs](https://wiki.php.net/rfc/const_scalar_exprs)

------
Kiro
I don't understand.

~~~
nycmattw
I actually don't understand either. Explain OP?

~~~
krzrak
86400 seconds = 24 hours

84600 seconds = typo ;)

------
nperez
Even if you're using 86400, remember the possibility of leap seconds if you
need absolute precision.

Time makes my brain hurt sometimes.

------
oxplot
This should never be entered like that. Not only it's prone to typos, it also
requires a comment to accompany it. Since just about every
compiler/interpreter folds constants, one should write it as 60 * 60 * 24
which would run without a performance hit.

------
Aaron1011
I first read this as 'Github search _takes_ 84600 seconds'. Oops :)

------
tantalor
A day is not always 24 hours.

[http://en.wikipedia.org/wiki/Daylight_saving_time](http://en.wikipedia.org/wiki/Daylight_saving_time)

~~~
fletchowns
But 24 hours is always 24 hours

------
beagle3
Easy mnemonic: 60 * 60 * 24 = 864e2 (scientific notation). Take down 2 each
time, and shove an e.

~~~
mcosta
Easier mnemonic: 60 * 60 * 24

The compiler is going to do the operation for you.

~~~
beagle3
Of course. I use 864e2 to remember that it is 86400 when I do calculations on
paper.

------
ejo0
check out 48600 seconds for ruby,
[https://github.com/search?q=48600+seconds&type=Code&ref=sear...](https://github.com/search?q=48600+seconds&type=Code&ref=searchresults)

~~~
grantismo
Looks like it's all coming from use of the tzinfo gem. See:
[https://github.com/tzinfo/tzinfo/blob/61fdd4359117e9a406c546...](https://github.com/tzinfo/tzinfo/blob/61fdd4359117e9a406c546bdc044a3e41faaa5d7/lib/tzinfo/offset_rationals.rb)

------
pkamb
`60 * 60 * 24`

