Ken Shirriff

A power adapter which can't handle a short is dangerous, period. Handling a short should be a part of the design of the power supply. Break open a low-quality third-party power supply for the last generation of iPhone and you'll see some downright dangerous, possibly lethal stuff. These dangers aren't really even mitigated by putting a shield around the plug.

http://www.arcfn.com/2012/03/inside-cheap-phone-charger-and-why-you.html

And a picture of what it should look like:

http://www.arcfn.com/2012/05/apple-iphone-charger-teardown-quality.html

Notice that on the shoddy power supply, the isolation between mains voltages and the other side is about 1mm. Manufacturing tolerances and component faults could easily bridge that gap and electrify the entire low-voltage side with lethal 240V mains -- shield and all.

Idiot-proofing low-voltage plug design doesn't help, because you've already lost if you let idiots design anything that plugs into the wall. Okay, shorting the plug might blow out your knockoff power supply and possibly start a fire, if the current limiting circuitry fails (which it shouldn't). But that knockoff was going to electrocute you anyway, at least if it lights on fire you still have the chance to run.

I visited pg's arcforum today http://arclanguage.org/item?id=12563 and got this info by "fallintothis":

http://github.com/nex3/arc/blob/master/help/arc.arc is from Anarki, a community-maintained branch of "vanilla" Arc. They wrote such a help function, but there are also other extensions and differences that are reflected in said help.

If you're new to Lisp, http://ycombinator.com/arc/tut.txt isn't a bad start. But there are countless Lisp tutorials out there.

As for online documentation: http://files.arcfn.com/doc/ + http://www.arcfn.com/2009/06/whats-new-in-arc3.html; see also http://arclanguage.org/item?id=12228, wherein I technically have another suggestion for learning Arc without the web ;).

[ Haven't dug in very far yet but Arc tutorial appears to be web development oriented, and you could look at the HN source code ]

Originally the formula was: (points-1)/(hours+2)^1.4 , but pg changes it whenever he wants, so the "gravity coefficient" is now different from 1.4.

You can read detailed analysis of the (published) formula in 2009 in http://www.arcfn.com/2009/06/how-does-newsyc-ranking-work.html

And there are a lot of secret coefficient corrections, for example the number of flagging that the submission received and the number of comments (if it has too many comments, it is too polemic and it is pushed down.)

If we use the 2009 formula we get

Points(P) Time(H) (P-1)^.8/(H+2)^1.8
7 2 0.3457
141 15 0.3177

that gives the ordering you saw.

This molecule is an amazing machine, powered by electricity. One thing I didn't realize until recently is how fast real molecules are compared to the animations. The molecular motor in the animation spins in real life at about 40,000 RPM - jet engine fast. The small molecules drifting around are actually moving at about 250 miles per hour. And instead of a few molecules drifting around, there are billions of molecules slamming into it every second.

I wrote a blog post a while back about how fast and crowded things are inside cells, that goes into more detail on this very protein: http://www.arcfn.com/2011/07/cells-are-very-fast-and-crowded-places.html

You are misunderstanding the original point. Lisp has certain qualities that are rare, designed in a special way and work together in special ways.

Almost none of the mainstream scripting languages uses simple code as data as Lisp does. Not Ruby. Not Python. Not PHP. Not JavaScript.

None of them have the roots in a meta-circular interpreter that fits on a page.

http://arcfn.com/2008/07/maxwells-equations-of-software-examined.html

None of those allow me to write symbolic computations in a simple and straight forward way like I can do it in Lisp.

I find that awesome.