I added a background image with a grid that extends 80px from top and bottom. There's also a small margin/padding/border reset and doctype just to make sure defaults and quirks aren't messing with anything.
To continue down this path of the "natural" way to vertically-center, font-size must also be explicitly set. This works http://jsfiddle.net/nJy8t/3/ . Though it's certainly not without it's flaws (we lose font-size cascading).
Personally, I am a little frustrated by OpenCV's move to C++ interface. Yes, it looks like a high-level language by mimicking Matlab style. But at the end of the day, the implementation uses many advanced C++ features, and ignored one thing that C++ is really good at: abstracting to objects / object interactions.
Computer vision task is very different, from, for example, a game engine. From engineering perspective, computer vision tasks are very functional. You throw an image to it, get some semantic information out of it, and done. The only objects there are images, and it is boring (Really? You need a inheritance relationship between different type of images? Tell me what's the behavioral difference!). Thus, object-oriented style is not the best abstraction for this kind of task at all. However, C++ is all about object-oriented programming! (and it is really useful for game engines, where you actually have a lot different objects and interacting with each other).
(Then here is the question, how to support different types of image? From the people I talked with, it seems to me the general conscious is to use generated code no matter you use c or c++. Generated code can be type safe, and still very fast. Effectively, this is what template does for OpenCV and macro does for ccv, although, both approaches are not the best.)
Take the end result, it is easy to use OpenCV's new interface (if you are familiar with Matlab), but hard to hack in. OTOH, it does provide quite a lot algorithms for you to experiment with, but then, if you need to write something new (the end goal of experimentation after all), it is really not an easy undertaking.
ccv takes a different path. Don't experiment with it, use it in your application, trust the underlying implementation is the best-of-its-kind, and you will be happy.
> However, C++ is all about object-oriented programming!
That really depends on how you use the language. Looking at the code I normally see there's almost no inheritance, but lots of static polymorphism through templates. Data tends to be stored in structs, tuples and the default data structures (vectors, mostly), and a lot of use is made of the new lambdas and the functional bits of the STL.
I know that you can write Java in C++ (and that many people do), but it's not really the language's raison d'être.
One of the creators of Django once told me, "Flask is what Django would have been if we designed it in 2010 instead of 2006." Sometimes smaller is actually better.
There's a difference between software having features and having opinions. For example, Pylons (http://www.pylonsproject.org/) ships with a large feature set but doesn't feel like you're forced to use any of them, whereas Django ships with a larger feature set and doesn't give you much choice.
Naturally, there are advantages and disadvantages to both approaches.
in the html of http://16s.us/sha1_pass/js/ add <!doctype html> to the top. this will prevent "quirks mode" in IE and String.prototype.trim will reappear.
Yes, the munching square picture is the same because the hamming distance of two binary numbers is their XOR.
As to why it looks similar to the visualization in the article, your hamming distance picture is essentially the multiplication table for a galois ring GF(2^n), where n is width of the bits of the binary numbers you were using.
Note that I say galois ring, not field; assuming that an n (for n even) bit unsigned binary number overflows as such: 0x00..01 + 0xFF..FF = 0x00..00, then your chart is the multiplication table of the ring formed by taking Z_2 modulo the ideal generated by the polynomial <x^n-1 + x^n-2 + ... + x^3 + x^2 + x + 1>, which is a ring since this polynomial is reducible (it has a root of 1).
A quibble of terminology: fields are rings too, so what you want to say is that it's not a field (or that it's 'only a ring') because the polynomial is reducible, rather than that it's a ring because the polynomial is reducible. It's a ring because it satisfies all the necessary properties--whether the polynomial is reducible or not has no bearing at all on whether the object under discussion is a ring.
the newest chrome has support for transferable objects that can be sent directly to a worker without being copied. this works with ArrayBuffer now, not sure if ImageData is transferable yet, but it should be eventually.
that solution
1. only works for text, which is part of eranation's rant.
2. only works if you know the exact height of the container.
3. isn't even centered: http://i.imgur.com/lz8Mq.png