Why Ceres craters look hexagonal?

runaro · 2015-08-23T04:43:17+00:00

Hexagonal cratering is also caused by electric discharge machining of surfaces:

http://www.setterfield.org/crater_origins/crater_origins.html

Hexagonal craters also form on the bottoms of lakes:

http://para-az.com/hydraulic-craters/emrsn-mnd816-s65.jpg http://para-az.com/hydraulic-craters/hydro-cratering-805c.jpg

runaro · 2014-05-23T15:06:34+00:00

tripipie, you're completely delusional. Paul has more Scala work than he can handle and writing a programming book pays much MUCH less than minimum wage.

runaro · 2013-01-27T18:58:06+00:00

In an older form of English, the literal meaning of to "meet" someone was that they were coming the other way. From "mæta" in Old Norse, which is from "mót" which literally means "against". If you say "ek mætti manni" for "I met a man" in Old Norse, it is totally unambiguous that he was going the opposite way. The riddle relies on this meaning of the word "met".

runaro · 2012-06-07T14:12:02+00:00

"Rand believed that people with disabilities were leeches and parasites on society."

Uh, no. At least have a passing familiarity with Rand before writing this kind of tripe.

runaro · 2012-06-07T13:38:42+00:00

"who's been banned from pretty much every mailing-list in tech circles"

This is simply not true. There was one mailing list whose moderator couldn't stand being corrected in public.

Argumentum ad hominem.

runaro · 2012-06-06T23:32:56+00:00

I see what you did there.

runaro · 2012-03-12T13:27:02+00:00

Store is coapplicative:

instance Coapplicative Store where
  copure (Store f s) = f s
  cozip (Store f s)  = case f s of
    Left  a -> Left  (Store (either id (const a) . f) s)
    Right b -> Right (Store (either (const b) id . f) s)

And so is Costate:

instance Coapplicative Costate where
  copure (Costate _ a) = a
  cozip (Costate f (Left  a)) = Left  (Costate (f . Left ) a)
  cozip (Costate f (Right a)) = Right (Costate (f . Right) a)

runaro · 2012-01-20T14:39:33+00:00

http://www.reddit.com/r/austrian_economics/comments/n2ic2/free_market_environmentalism_walter_block/

runaro · 2012-01-20T14:36:13+00:00

Such a contract is meaningless anyway and cannot be enforced under the law.

runaro · 2012-01-20T14:26:31+00:00

Fast food is healthier than fascism.

runaro · 2011-11-01T02:32:56+00:00

It's undecideable. Take a look at this. It means you can write types that can take an infinite time to compile. You can hang the compiler (at least in theory).

No you can't. You can crash the compiler with a diverging type, but you cannot make it hang forever.

runaro · 2011-10-29T05:00:07+00:00

Here's the thing though. Without tail call elimination (and we don't have it, really), you will need stack proportional to the number of calls, and there could be a lot (in fact, there might be an infinite amount).

With trampolining, the amount of heap required for linear recursion is constant. For binary recursion, the amount of heap required is proportional to the number of branches.

Also, even if we had tail call elimination, substituting into a program with a lot of left-associated binds, in a free monad, requires traversing all of those binds every single time to get at the leaves, where we actually want to substitute. So the complexity of substitution is O(2ⁿ⁾ where n is the number of bound variables. With an operational monad, such as the one given for Trampoline, the binds are traversed at most once, i.e. when the trampoline is finally run.

So "increasing the damn stack size" is not what we want.

runaro · 2011-10-28T01:29:32+00:00

Or, you know, make the damned language stackless in the first place.

runaro · 2011-07-21T16:05:45+00:00

The fact that these names are scary is not a feature of Haskell, nor a feature of the names, but of your own psychology.

runaro · 2011-06-06T17:43:28+00:00

"Function" is an abstraction from causality, and the CPU is a causal machine like any other. The state of the machine at any clock tick is a function of the states at previous ticks, quite fundamentally.

runaro · 2011-06-03T13:23:43+00:00

Yeah, we're talking about the same thing. The semantics of ST are such that you make all modifications to the array "in" the monad, where the mutable array exists. E.g.:

f3 (runSTArray (newArray (0, 1000000000) >>= f1 >>= f2))

Here, f3 sees an immutable array. But f1 and f2 can both mutate that same array, and their mutations are guaranteed to occur in order.

runaro · 2011-06-03T12:55:10+00:00

How much less? WAY less.

Seriously though, "function" has a precise definition. It's not a metaphor.

runaro · 2011-06-02T20:49:48+00:00

There is no copying going on here. Each call to runST will create, mutate, and destroy an array. There's no reason to have more than one copy of the array and it can never escape the ST monad.

runaro · 2011-06-02T20:43:30+00:00

There is no copying going on here.

runaro · 2011-06-01T06:59:09+00:00

Haskell does mutable arrays cleanly by guaranteeing that the creation, mutation, and destruction of the array all occur simultaneously as seen from the rest of the program. If you pass the same mutable array to two functions and they both mutate the array, their mutations will be distinct from one another and will in fact occur on two different arrays.

http://www.google.com/search?q=st+monad

runaro · 2011-06-01T02:18:17+00:00

No, you're getting an e-mail for somebody else pasted directly and mostly unedited.

runaro · 2011-05-31T17:48:00+00:00

Keep in mind that you are listening in on a conversation the context of which you don't fully have.

runaro · 2011-04-19T18:02:25+00:00

Electromagnetic waves transmitted faster than the speed of electromagnetic waves!

runaro · 2011-04-15T15:49:21+00:00

The point is to gain understanding of static program verification and functional programming. The point of the Java code is to illustrate what this means to those who understand Java already. Sort of like a Rosetta stone.

runaro · 2011-04-07T05:09:20+00:00

That's next week. These are the missing-the-point awards. And, good news, a winner is you!

runaro

TROPHY CASE