Calmer Than You Are

For further reference (as it seems I've been downvoted possibly for my own snark on this one) - since I can no longer edit the original comment, here are some references This appears to be the one I recall: http://calmerthanyouare.org/2015/03/19/betteridges-law.html My numbers were off it's actually 46% "non-polar", 20% "yes", 16% "maybe" and, 15% no https://news.ycombinator.com/item?id=9232419 Additionally there was a publication in a statistical journal which also discussed the "phenomenon" http://link.springer.com/article/10.1007/s11192-016-2030-2 which also found that it wasn't a factual assertion (in academic papers). Anyways - if the downvote was for something other than my own snark I'd love to hear what it was. Apologies for coming off as a jerk.

"Is Betteridge's law of headlines correct?" (brilliant title, given what follows) http://calmerthanyouare.org/2015/03/19/betteridges-law.html "In other words, it appears as if roughly a quarter of all headlines which end in a question mark can be answered by the word no. You can go ahead and call that Linander’s law of headlines, if you will." Don't miss the data: https://gist.github.com/matslina/64601f39ef12bd653be6

BrainFuck is a great place to start because it's pretty simple. I started with this post on the PyPy blog: http://morepypy.blogspot.co.uk/2011/04/tutorial-writing-interpreter-wi… This repository helped as well: https://github.com/thoughtpolice/bf-pypy Getting a basic interpreter working wasn't hard, but I attempted to add a few of the optimizations listed here[1], which meant adding some form of AST and stuff to manipulate it. This is where I got a bit stuck with regards to performance as some of my optimizations meant the program should have been faster, but instead it slowed down. 1. http://calmerthanyouare.org/2015/01/07/optimizing-brainfuck.html

Cool! Seems to be citing this nice post here: http://calmerthanyouare.org/2015/03/19/betteridges-law.html I didn't realize the biggest reason against it is that the majority of headline questions aren't yes/no. Oh well, it's still funny to silently answer any (yes/no) headline question with "no!" before reading.

For the last few days I have been wondering if there is any analysis to see if this "law" is accurate. Is there anything other than this? > With 46% non-polar and 20% answered “yes”, at least two thirds of our headline sample violates Betteridge’s law. We conclude that it cannot be “mostly correct” either. http://calmerthanyouare.org/2015/03/19/betteridges-law.html#:~:text=Be…

Is Betteridge's law of headlines correct? http://calmerthanyouare.org/2015/03/19/betteridges-law.html

There's this: http://calmerthanyouare.org/2015/03/19/betteridges-law.html Delightfully, the article itself seems to assess the letter of Betteridge's Law while ignoring, and therefore embodying, its spirit. And also, naturally, deliciously, walks straight into the obvious trap in the end.

Interesting, I found this article which backs you up http://calmerthanyouare.org/2015/03/19/betteridges-law.html

Writing a bf interpreter or compiler is the first thing I do in a new language. I have taken to representing the tape as a linked list which allows for a one-pass optimizing pass whereamong other things +++ is turned into +3 and [-] into tape[cur] = 0. I really liked reading the code since it is a problem I am familiar with. Edit: here is a link with some simple optimizations http://calmerthanyouare.org/2015/01/07/optimizing-brainfuck.html All these are just pattern matching, which make them all simple!

Libc qsort() isn't quicksort in several of the popular libc implementations. For example, it's (usually) a merge sort in glibc. http://calmerthanyouare.org/2013/05/31/qsort-shootout.html

Closest I could find to a recursive Betteridge's Law: ;) http://calmerthanyouare.org/2015/03/19/betteridges-law.html

Even basic optimizing compilers collapse consecutive + and - operations into a single constant size instruction and does a dozen other optimizations so in practice the instruction density is crazy high compared to naively executing every BF operation individually. It could have been interesting if they used an optimized ISA inspired by [1]. There's a reason why CPUs that can execute JVM bytecode directly never caught on: They cannot apply any of the optimizations that a JIT or compiler can. [1] http://calmerthanyouare.org/2015/01/07/optimizing-brainfuck.html

There is also some ability to explore optimization strategies. http://calmerthanyouare.org/2015/01/07/optimizing-brainfuck.html As it’s such a limited language, it is something that may be more accessible (compare optimizing MIPS).

The original post links to this page: http://calmerthanyouare.org/2013/05/31/qsort-shootout.html There is an explanation provided that may be the reason, but it is not entirely convincing. Smoothsort is a variation of heapsort that performs especially well on nearly sorted inputs. It’s a pretty complicated beast and it does take some effort to wrap one’s head around it. Keith Schwarz has posted a nice walkthrough that the interested reader should check out. Considering that musl libc puts simplicity among its design goals, the choice of smoothsort could seem odd. The code is however clean and readable and getting an O(nlogn)O(nlog⁡n) worst case with near linear complexity for nearly sorted inputs is a pretty sweet deal.

http://calmerthanyouare.org/2014/09/30/brainfuck-java.html some of the issues encountered when writing a brainfuck-to-java compiler in brainfuck Yo dawg, etc