herdrick

EDIT: If peregrine's comment is right, then we're arguing about something that isn't happening. I hope so.

Oh no! Clojure is choosing the route of premature opt. What a terrible shame.

Also I think the larger effect on your experiemt is the "trail" thing the author mentioned. If you spin the front wheel 180 degrees (possible for some bikes) and try again I think you'll mostly see the reverse result: pushing the bike backwards will let it roll a while, but pushing it forwards will result in immediate crash. But the leaning effect you mention could be important too, I don't know.

This is a lot simpler than it seems. Highly experienced, working programmers are rare because there were far fewer programmers twenty years ago compared to today. So of course they are now far outnumbered by newcomers.

This happens in any booming field, in fact any booming demographic.

The explanation of the 'naive' part of Naive Bayes isn't quite right, though. Throwing out the possibility of the animal being human based on the datapoint "four legs" is orthogonal to naivety. A more sophisticated Naive Bayes system could reject classifying an animal as human based on having four legs, and conversely a non-naive system i.e. one that used joint probabilities of the features, might not be more likely to.

I guess the most rational way to do that would be to express and calculate the conditional probabilities with some statistical distance, like the # of standard deviations. So 100k examples of humans without a single one having the "four legs" feature would make that a very strong indicator of being non-human. And that'd work just as well with a naive algorithm as any other.

Is there a name for this?

By this I merely meant, "I don't understand what you are saying". Hope that was clear.

There are times when the imperative style is more natural.

Sadly, as far as I know, you need to roll your own tree-reduce.

But what I really want it something that doesn't require dereferencing syntax:

    (zet! c (* c x))

What I was looking for can be done with atoms, and is made more like traditional lisp mutation by defining a "st!" (or maybe "zet!" is a better name).

    (defn st! [atm v]
      (swap! atm (fn [_] v)))

    (def fns
      (let [c (atom 0)]
        {:add (fn [x] (st! c (+ @c x))) 
 	:mlt (fn [x] (st! c (* @c x)))}))

    > ((get fns :add) 3)
    3
    > ((get fns :add) 3)
    6
    > ((get fns :mlt) -5)
    -30

    (def fns
         (let [c (atom 0)]
           {:add (fn [x] (swap! c #(+ % x)))
    	    :mlt (fn [x] (swap! c #(* % x)))}))

Not a good thing. The word 'must' is the glaring red flag.

EDIT: I wrote that before reading. The title isn't very relevant to the post.

Pretty clueless estimates I'd have to think.