2,127 karma · joined July 3, 2011
Email: tylerneylon@gmail.com
http://en.wikipedia.org/wiki/1729_(number)
That's a very obscure reference, though, so I apologize for sending anyone looking based on my previous comment.
I wanted to express something like "hey, this guide is for programmers and is surprisingly short and easy to consume considering it covers the large majority of the language." The current title seemed a bit snazzier.
It was a post on medium.com about Pac-Man. Medium tracks number of views and number of reads per day. I think they use a metric that's not just time-on-page to differentiate between views and reads. My post had about 26k views and about 15k reads the day it was on the front page.
You can see the exact state of the game at day one:
git clone git@github.com:tylerneylon/pacpac.git
git checkout 4abf17ca62dffd2ac3245f6ab06cc28fb9021791
You can return to the latest commit later via:
git checkout master
You can get the game engine (required to play) from http://love2d.org .
Also, the code for PacPac is not very clean. Just like javascript, globals in Lua are the default, easy to use, and require discipline to avoid :)
A bottleneck to mainstream use is the lack of overlap between hackers/devs and people who are most influential in academic publishing, such as senior editors. To developers the question is: if editors want to post their articles on the web, why don't they just do that? To editors, the question is: how can I practically make my journal open access? There is a need for technology to assist in setting up open access journals.
Some people are working on solutions, but it's not obvious what that solution will ultimately look like. There is some trial and error happening, and I hope great progress is made while the problem has the attention of the community.
Hiring/tenure attitudes can include respect for people who choose to avoid closed-access publishers. This doesn't punish people who continue to publish the old way. If done right, it only helps the careers of those who avoid closed journals.
By the way, I somewhat snarkily complained that your comment was snarky. That was hypocritical of me, at least in spirit. Sorry about that. I like non-snarky, straightforward comments.
I'm glad you're signed up at the cost of knowledge. My personal role in open access is mainly as the creator of that site.
The case of academic publishing is particularly strange. The following parties want articles to be freely available: the authors, universities, funding agencies, and the taxpayers who pay for some funding agencies. The flow of money is so perverse, and the culture of tradition so strong, that no one has a good immediate incentive to switch to open access, though.
This is an important problem because 99% of the world has no access to research that essentially everyone involved, except the publisher, wanted to be free. Or, if you think money is more important than access to research, consider that in 2011, Reed Elsevier made more money than any of these: Verizon, Nike, Mastercard, FedEx, Bank of America, Delta, or Amazon.com. And their huge profit margins come from a strongly inelastic, broken system that funnels money from our universities and taxpayers.
A good comment would at least say why you think it's a difficult problem (that the author has supposedly missed).
As far as hiring or giving tenure based on merit instead of journal prestige, this is achievable. It's hard because traditionally journal names are extremely important. But it's doable. When I was a grad student, I was personally aware of the process of hiring people in my field. The problem right now is that one person could say, "X is good but candidate Y has two articles in Awesome Journal, so Y seems better." That statement implies Y has good work, but we need to make room for the reply, "Yes, but X has done better work and avoided Awesome J. because it's closed access." It's an attitude shift, which is hard, but doable.
I left academia years ago but continue to (try to) do research. Resources like scholar.google.com can often help find a free-to-read version of a paper, which is great. But access to a single key paper can make or break your progress. I've personally dropped many, many hours of work because of this problem - I couldn't reasonably access key literature that I needed.
I'm saying it's all BS (it's not) but that there's too much.
I don't think it has to be that way. Example ideas:
* Writing in philosophy could be improved (http://tylerneylon.com/a/writing-about-philosophy/)
* The attitude toward 'what is philosophy?' could be improved (http://www.richardprice.io/post/35542139118/one-hypothesis-a...)
Here is a variation which, unless I'm missing something, would be a little simpler still and require less full-memory loops:
1. Count #1's in memory (possibly mod N to avoid overflow). 2. Invert memory. 3. Count #0's in memory. 4 Invert memory.
I think this would catch the same errors (stuck-as-0 or stuck-as-1 bits).
One difficulty is that multiple errors could cancel each other out, at which point you can do things like add checkpoints in the aggregation, or track more signals such as number of 01's vs number of 10's. In the end, this is like an inversion-friendly CRC.
I went from grad school to Google in nyc, where the working culture supported going home by around 6pm. That felt like the opposite of grad school, where I regularly slept in my office.
font-weight: bold;
would increase readability.
http://tylerneylon.com/a/imghist/ (and source) https://github.com/tylerneylon/imghist/blob/master/imghist.p...
That also includes color histograms.
Thoughts on actually using this:
* If a human is using the color output, it's fun to weigh the colors by cluster sizes. * To find human-perspective dominant colors, it helps to throw out very-light/dark pixels. * Dribbble does a very good job of this - look at any of their individual photo pages. * For production use, C would be much more appropriate at solving this problem (but python is more fun to use).
Another cool application of color analysis like this:
http://www.vijayp.ca/blog/2012/06/colours-in-movie-posters-s...
This is old-school, but a long time ago I wrote a java applet to help explore this function on the complex plane:
http://www.math.nyu.edu/~neylon/applet1/
If you move around the red square, you see a lot of the circular shapes that look similar to those in the fractal.
I don't completely understand the algorithm being used, so I'm not sure how to gain more confidence on this guess.
When we have a timing function f(n) we pretend f has one input, which is n = the size of the input to the algorithm. In reality, it's actually more like f(n, m) where m = a parameter specifying the _exact_ input to the algorithm. (Example: sorting algorithms have many possible input lists of length n.)
So when we write f(n) = O(g(n)), we are trying to make two simplifications: (1) Simplify away the actual input, replaced by only the _size_ of the input; and (2) simplify the actual function f to something that describes f but is much simpler.
I will make up an artificial example that is not perfect but is useful to explain the ideas. Suppose for any input size n we have parameters m in the range [-n-sin(n), n+sin(n)] and the exact timing function
f(n, m) = n + sin(n) + m
Then the first simplification is to determine how to ignore m. We could pick out the best m for n (the smallest f(n, m) for a fixed n), pick out the worst m, or take the average over all m. This is best-case, average-case, and worst-case complexity. For this function, we have:
f(n) = 0 [best case] f(n) = n + sin(n) [avg case] f(n) = 2(n + sin(n)) [worst case]
Then we could get an upper bound on _any_ of these.
f(n) = O(1) [best case] f(n) = O(n) [avg and worst case, not always the same, but they are the same in this example]
If we wanted a lower bound, we could say that
f(n) = Omega(n) [avg & worst case]
because f(n) >= n - 1 for all n (in general there could be more room for flexibility on the right-hand side, but it's not needed in this example).
The point here is that step 1 chooses a simplification across input instances, that we call worse case or average case, etc; and step 2 chooses a simplification in how to write down the function f(n), and this is what we call an upper bound for big-oh, or for theta, both an upper and lower bound.
If you're more of a CS person than a mathy, I recommend Sipser's Introduction to the Theory of Computation. This one is written in friendly yet precise terms, and I found it a pleasure to read.
There is an extremely active world of researchers and many (I believe) developers for which big-O definitely and clearly means "upper bound" and not the stronger theta notation. Basically all research papers in CS use O as an upper bound, and those, to me, are the definitive active voices. Beyond that, purposefully confounding O and theta is actually clashing different ideas together - ideas that have been separated for their utility. Often knowing the O notation requires some thought, and knowing theta is even harder; in practice what is most concerning is an upper bound, so that idea is important and useful. If the default object in language became exact complexity (not an upper bound), our lives would be much more difficult -- the practical thing to talk about would end up being whatever new notation replaced the idea of upper bound for complexity (aka the "traditional" big-oh).