drostie

It is defined in this paper itself; see section 3 titled "Language," beginning "In this section we formally define Cogent, including its linear type system, its two dynamic semantics — update and value — mentioned earlier in §2, and the refinement theorem between them." Also see figure 5, which is its formal syntax after desugaring.

Viewpoints Research Institute, see e.g. http://vpri.org/html/writings.php which has papers like "Checks and Balances - Constraint Solving without Surprises in Object-Constraint Programming Languages" and Alessandro Warth's "Experimenting With Programming Languages" (which led to OMeta/JS, which is I think on GitHub), as well as a ton of Alan Kay talks on fundamental new computing technologies http://vpri.org/html/words_links/links_ifnct.htm .

The way that Datomic uses Datalog is really interesting from a perspective of "new approach to programming" (databases).

Erik Demaine's course on advanced data structures gives some interesting ideas for time-travel-based games: https://courses.csail.mit.edu/6.851/spring14/ . His work also has application to other fields like creating an efficient in-app version control system http://www.cs.utexas.edu/~ecprice/papers/confluent_swat.pdf .

Lots of cool stuff on HaskellWiki; for example https://wiki.haskell.org/Functional_Reactive_Programming .

If you really want to jump into the deep end there's a whole blog called Lambda: the Ultimate about new approaches to programming: http://lambda-the-ultimate.org/

Some answers:

    1. Solve for positive x: 
        x (8 sqrt(1 - x) + sqrt(1 + x)) <= 11 sqrt(1 + x) - 16 sqrt(1 - x)

The upper bound is clearly x=1 because the square roots cease to exist for x > 1 and and substituting in x = 1 - epsilon^2 gives to first order (8 e + 1) <= (11 - 16 e) which works because 8 <= 11. Does this thing have a root in [0, 1]?

The inverse of y = sqrt(1 + x)/sqrt(1 - x) is with some work x = (y^2 - 1)/(y^2 + 1) so when we divide through by sqrt(1-x) which we know now to be positive, and replace the above, we find:

    (y^2 - 1)/(y^2 + 1) * (8 + y) = 11 y - 16

Expanding out we're looking for a root of

    -10 y^3 + 24*y^2 - 12 y + 8 = 0

Dividing by -2 to normalize somewhat:

    5 y^3 - 12 y^2 + 6 y - 4 = 0

At this point I almost gave up (since it's a cubic and I had no guarantee that x was rational) but got lucky, I started trying positive integers to see where this transitions from negative (y=0) to positive (5y^3) and accidentally found that y=2 solves the equation. Sending it back through I find 3/5, so assuming that it doesn't double back somewhere in the interval [3/5, 1] that's the interval that we're looking for. Phew!

    2. Find all functions F(x) : R -> R having the propery that for any x1 and x2, 
       F(x1) - F(x2) <= (x1 - x2)^2.

Yeah, if you're just entering a university you're probably not going to get this one. Rewriting x1 as x + dx, x2 as x, then this says F(x + dx) - F(x) <= dx^2. With some limits and the Squeeze theorem, this restricts the functions to be differentiable with derivative zero, so they are constant functions. By inspection that is not just necessary but also sufficient.

    3. Given a triangle ABC construct with a straightedge and compass a point K on 
       AB and a point M on BC such that AK = KM = MC.

This seems in general impossible except for some very specific triangles -- is that true? For example if |AB| = 2 and |BC| = 1, it seems that the only point on AB which could possibly be a candidate for K is the midpoint, with M being B. But the only way that the distance from K to M is the same is if BCK is an equilateral triangle, which requires furthermore that the angle BAC is 60 degrees, no?

    4. Solve 2 cubert(2y - 1) = y^3 + 1 for real y.

So y = 1 is an obvious solution. Cubing both sides we get

    y^9 + 3y^6 + 3y^3 - 16 y + 9 = 0

Then doing polynomial division by y-1 I get

    y^8 + y^7 + y^6 + 4 y^5 + 4 y^4 + 4 y^3 + 7 y^2 + 7 y - 9.

At this point I got stuck and turned to automated tools, which say that this is factorizable as:

    (y^2 + y - 1)(y^6 + 2 y^4 + 2 y^3 + 4 y^2 + 2 y + 9)

Graphing the right hand side it seems to be consistently positive, so that just leaves the left hand side, which is -1/2 +/- sqrt(5)/2. That's pretty difficult.

If you need help on the difference between "publicly viewable" and "open source" see this answer to a related question on the Open Source Stack Exchange: http://opensource.stackexchange.com/questions/2338/can-i-use...

Not quite. With apologies to Missy Elliott:

    It needs the client, to be served it. 
    It's Heartbleed if you flip it and reverse it.
    [.ti esrever dna ti pilf uoy fi deelbtraeH s'tI]
    [.ti esrever dna ti pilf uoy fi deelbtraeH s'tI]

    If you SSH in, we can search it
    And if you're roaming, steal your private key bits
    [.ti esrever dna ti pilf uoy fi deelbtraeH s'tI]
    [.ti esrever dna ti pilf uoy fi deelbtraeH s'tI]

    B, B, on BSD
    or any platform with a bad libc
    [Why-thai,-thai-o-toy-o-thai-thai]
    [Why-thai,-thai-o-toy-o-thai-thai]

    'Cause, they, don't zero bits,
    Not that anyone expected it.
    'Aint no shame, Libc, do your thang,
    OpenSSH's do-nothing feature here is to blame.

The Haskell void type () is also a None, and it's pretty helpful. The easiest example is `putStrLn :: String -> IO ()`.

The most interesting part of this disclosure is:

    Internal stdio buffering is the most severe of the three problems
    discussed in this section, although GNU/Linux is not affected because
    the glibc mmap()s and munmap()s (and therefore cleanses) stdio buffers.
    BSD-based systems, on the other hand, are severely affected because they
    simply malloc()ate and free() stdio buffers.

Basically the exploit reveals a big chunk of memory where, very often, your private keys happen to live. The memory has been freed, but on BSD systems the memory that was freed has not been zeroed in any way, so you still see the private keys.

So this is an interesting bit of thought but I'm trying to figure out what it corresponds to in Haskell. Clearly what they're doing with `S` is effectively a `Reader s` monad in `Control.Monad.Reader`, and clearly what they're doing with `a -> a` is the `Endo a` monoid in `Data.Monoid`.

We can definitely create a `newtype` which composes any applicative with a monoid in the appropriate way:

    newtype ApMonoid a m = ApMonoid (a m)
    instance (Applicative a, Monoid m) => Monoid (ApMonoid a m) where
        mempty = pure mempty
        mappend (ApMonoid x) (ApMonoid y) = Wrap $ mappend <$> x <*> y

Then they have two data types: (1) they pull in a bunch of `Extras` up front and then each transformer successively pares down the extras to some subset of data that it cares about, then (2) each function transforms the search `Results`. We could say that this is:

    data Extras = Extras {e1 :: {- type1 -}, e2 :: {- type2 -}, ... eN :: {- typeN -}}

and their resulting transformation looks like:

    transN (eN extra) . ... . trans2 (e2 extra) . trans1 (e1 extra) :: Results -> Results

so I guess I'm trying to store `transN . eN` as something like an `ApMonoid (Reader Extras) (Endo Results)` via the above. The logic looks pretty solid.

However, if it doesn't kill the basic logic, it might be more Haskell-y to compose these by lifting the monoid to an applicative using `Const`, so that in this case:

    newtype ApAp a b x = ApAp (a (b x)) deriving (Functor)
    instance (Applicative a, Applicative b) => Applicative (ApAp a b) where
        pure = pure . pure
        (<*>) = liftA2 (<*>)

We would instead say that this is `ApAp (Reader Extras) (Const (Endo Results))`. Can anyone with more experience with such things comment on whether those are the same? I'm a little shaky here.

Also, there's no generic way to "drop" an applicative to be simply a monoid, right? We need an existing Monoid to feed to `ApMonoid`, no?

The comments mention that the rules were changed to disallow out-of-band bargaining after this event, which is important because this is one of the core solutions to the Prisoner's Dilemma (which is what they're playing, and is not a zero-sum game). The solution in general is contract law.

The verbal agreement "If you do this and I do that then I will split the money 50/50 with you after the show" is a verbal contract which (due to the cameras recording the event) is nevertheless indisputable. You are giving them a task to accomplish in exchange for a promised financial reward. They have all rights to sue you in court if they did what you asked and you didn't pay them for it.

What's really interesting is that he promises to split 50/50. In theory a rational actor who could commit to these things absolutely would say, "Look, I am pre-committing to steal, and I will give you $100 after the game if you choose split." Then it is still rational for the other guy to choose "split" (getting $100) rather than "steal" (getting 0). However most people, in study after study, will be insulted by the disparity of only getting 1% of the winning, and the insult is magnified by the camera: it is public shame. So in some sense being insulted by unfairness introduces out-of-band costs that also tend to pull you to splitting the money, and splitting it more fairly.

Very cool. I'm very interested to see what you'll build with it.

With any cross-cutting abstraction like this, it's kind of like developing a new potting soil: I feel like I need to know what flowers you're trying to grow to understand why you made the choices you made.

The problem is that then you need to force customers to be on Google/Facebook/whatever.

There was (Still is!) something very similar in an organization called CAcert[1], which was a predecessor to the current Let's Encrypt project (free SSL certificates) that hasn't succeeded dramatically because it hasn't been able to get its root certificate into browsers.

Basically they host parties, usually alongside a Linux or BSD conference, where trusted members will look at your legal documents and then affirm on their website that you are who you say you are. Some amount of "you are who you say you are" was then needed to get a free SSL certificate.

But imagine that in this context: everyone keeps one secure CAcert account, and then when you need to reset your password, some sort of OAuth handshake with CAcert proves it. You have one secure account with CAcert, and all of your utilities and cell phone stuff and PayPal will only reset your password with a handshake with the CAcert servers.

[1] http://www.cacert.org/

Thanks for the first of these, I've put it on my "eventually if I ever get serious about writing this programming language" list.

I think people here will be really interested to know that this is an active technique in the "quantum hacking" world as well. As you probably know, quantum mechanics very often offers 100% security about creating shared keys which nobody else knows -- but there is a very active physics subfield called "quantum hacking" which says "well, but you're assuming that your device perfectly embodies these equations and the reality is it doesn't, so let's see what happens if we drive up the parameters to a non-ideal regime, can we run a Man-in-the-Middle attack then without you both knowing about it?"

Here's for example a pop-science article about using camera zapping on Vice Motherboard:

http://motherboard.vice.com/read/a-new-quantum-hack-just-bur...

The solution to this was to include a filter which prevented oversaturation at the target wavelengths, but it turns out you could just blast it with some other wavelengths...

http://www.technologyreview.com/view/530181/the-next-battleg...

So it's a really fun-looking discipline, lots of groups hiring postdocs for it etc.

(1) Monadic programming gets really hard to understand if you don't have a strong type system correcting you when you screw up the difference between `x`, `m x`, and `m (m x)`. The tendency in weak type systems is to autopromote `x` to `m x` with `return`, but this can make it impossible to see if you need to deconstruct `m (m x)` to `m x` with `join` in any given application, unless you just auto-flatten everything, which sometimes (especially in the list monad!) is not what you want.

(2) Monadic programming gets hard to understand if you can't cleanly split out functions into having just one argument and one output.

Translation for people who don't know what a "monad" is: occasionally there are type-adjectives (I'll use the example "blue") where there is a canonical way to make any object into a blue object (called `return`), and a canonical way to make a blue blue object into a blue object (called `join`), and a canonical way to take some function from objects to objects and turn it into a function from blue objects to blue objects (called `fmap`).

One example is the adjective "either an X or a ____", which is written in Haskell as `Either x`. The canonical way to take a Y and `return` it into "either an X or a Y" is to say "it's a Y -- the type on the right." In Haskell we'd say that `data Either x y = Left x | Right y` and that this `return` function is `return y = Right y`.

Similarly the canonical way to map a function `y -> z` over such an `Either x y` to get an `Either x z` is "if the value is an X don't do anything, otherwise do the function to the value and collect the end result." This is written `fmap zy exy = case exy of Left x -> Left x; Right y -> Right (zy y)`. Finally, the canonical way to take an "either an X or an (either an X or a Y)" into "either an X or a Y" is just: if you've got an X, it's an X; if you've got a Y, it's a Y:

    join ex_exy = case ex_exy of 
      Left x -> Left x
      Right exy -> case exy of 
        Left x -> Left x
        Right y -> Right y

So it's adjectives which are (a) universal [we can apply them to anything], (b) collapsible [we can take an `m (m x)` and turn it into an `m x` and (c) mappable [we can take an `x -> y` and apply it to an `m x` to make an `m y`].

Haskell became obsessed with them because this structure describes computer programs really well. Suppose you build in a data type for "a program which produces a...". Then the basic "program composition" operator looks like this:

First, take two inputs: (1) a program which produces an X, (2) a function which takes X and produces a program which produces a Y. Then, yield a program which will (when run) produce a Y by first running program (1), then using the X generated as an input to the function (2) to compute a program which produces a Y (3), then runs (3) to produce the y.

The type signature here is `(IO x, x -> IO y) -> IO y`. This curious function is called `bind` and it can be more easily thought of as a combination of two separate steps: `fmap` the `x -> IO y` on the `IO x` to produce an `IO (IO y)`, then `join` the programs to produce an `IO y`. "A program which produces a ..." is thus a special case of a monad, an adjective which supports these three operations (`return` is "produce a program which does nothing and yields this Haskell value").

And you care about all of this because being all indirect -like about computer programs allows you to metaprogram up an impure program in a pure language, which is how Haskell does I/O.

So the translation of the above points is that (1) this whole process gets confusing if you don't know the difference between a wagon, a blue wagon, and a blue blue wagon at compile time, and the tendency in a Lisp is to say "I saw a wagon, I wanted a blue something, so let's just quietly use the `(paint-blue wagon)` subroutine to keep going," and "I saw a blue blue wagon, I wanted a blue something, so I am happy." You can force things to always use some `(coalesce-blue-paint ___)` function to always flatten blue-blue Xs into blue Xs, but this is usually counterintuitive. (2) You can't even clearly articulate what `fmap` does unless you can cleanly say "I have a function from wagons to wheels, and I want the corresponding function from blue wagons to blue wheels." If your functions are taking a bunch of extra parameters, like a wheel-index of "front-left, front-right, back-left, back-right" then it gets hard to say "here's the wagon input that I want to become a blue wagon input, please leave my wheel indexes alone!"

The issue is, we don't know any of the things you've said. (A) We don't know that there was a robbery. [We know that someone said that someone may have attempted to break in to a house; we don't know that it was successful or that anything was stolen or even if the person really was unauthorized. I was once stopped by some guy's neighbors because they knew he was out of town and saw me entering and exiting his house; I had entered with a house key and was filling in for a friend in feeding the guy's cat. Had they called the cops to report it instead of confronting me directly, that sort of description might have circulated.] (B) We know that the police officer followed him for a few minutes before stopping him (he walked a block and a half to a crosswalk after stopping his car, and then he crossed the street), but also that he was walking in the direction of downtown Boston, which is where the officer said that the event took place. Given these I would conservatively estimate at least a 15-minute gap, but it could easily have been several hours. (C) The closest house in that direction is indeed about 200m away from the burrito place he was stopped at, but we have no reason to think that the event happened there and not, say in the mass of houses that are 2km away in the same direction, or possibly past downtown in the many houses in Cambridge. In fact the response that he elicited ("I came from Dedham", more than 10km away in the opposite direction) suggests that the officer was not pointing towards some specific house but rather gesturing wildly in the direction of downtown Boston and Cambridge.

> If you are indeed close to the given description of a criminal complaint, they're going to check. They have to check.

No, no they don't. Goodness.

Let me break down this problem for you. Maybe a quarter of Boston is black, half of those are men, the height/weight thing probably doesn't rule out more than half the people (and the police clearly admit in this interaction that it's a stretch to say he's that light-weight). At least 10% of men will go out with a knit cap on a cold Boston day. You multiply those together and you get 0.00625. You, and the police officers, together are thinking, "man, that's a surprisingly low probability, only an 0.625% chance that we'd come across a guy matching that description! We'd better detain him!"

But that's a dangerous fallacy, in a family called the false positive paradoxes. Usually we surprise kids in statistics class with these by saying, "hey, you live in New York and took a 99%-accurate test for HIV and it came out positive, what's the chance that you actually have HIV?" And they answer 99%. But the real answer is, you probably don't have it, and the probability is closer to one in three. How can this be? Well, you can look up these statistics for 2012, where there are 130,000 cases of HIV/AIDS in New York, which has nearly 20 million people, so your prior probability of having an HIV infection is only something like 0.65%; then the 1% false positive rate means that your 99%-accurate test has only increased your probability of actually having an HIV infection to about 39%, as the false positive set is larger than the true positive set.

It's even worse in this case, where you're looking for one person. Your 0.625% chance is spread out over a city of 650,000, meaning that over 4,000 people are subsumed by this description. Given all of the facts cited there is a less-than-0.025% chance that the guy they are detaining has done anything wrong.

Imagine the absurdity if they actually worked out and then quoted the statistics: "Look, we're 99.98% sure that you're not the guy we're looking for, but we're detaining you anyway, because we demand six nines of certainty that you're not who we're looking for. Oh, you have a valid photo ID and we can easily check that someone with that name is a professor at this college? Roots in the community? Well, that only bumps you up to about 99.999% sure that you're not the person we're looking for, but that's only five nines, buddy, not enough for us to let you go about your business. We've got to get the woman who made a complaint to look at your face to make absolutely sure that you're not the criminal who we think you might with 0.001% chance be."

They absolutely do not have to check that. Certainly they don't have to stop you to check that -- at five nines surely they can let you go about your business and check up with you at your residence if they receive sudden incriminating information.

When Lewis Carroll discusses a similar logical problem in "What the Tortoise Said to Achilles" it comes from the perspective of a Zeno paradox which cannot be resolved in the same way.

Essentially, Achilles says "A, therefore Z." Tortoise says, "Well, suppose I don't see the connection here, you have some symbols on this side and some symbols on that side, could you help me?" So Achilles modifies this to, "A, and A implies Z, therefore Z." And the Tortoise says, "well, that sounds very good and I trust your proof that A implies Z but I'm still not seeing the connection here. Could you help me connect those left hand things to the right hand thing?" So Achilles modifies this to "A, and A implies Z, and (A and A implies Z) implies Z, therefore Z." And the Tortoise says, "aha, of course '(A and A implies Z) implies Z' ... but wait, now that I've written that down, I again don't see the connection here...". Essentially the point is that our generic rule that replaces "x and x implies y" with "x and y" is a process which lives outside the declarative scope of formal logic. (In the Curry-Howard isomorphism: you can have a value of type `x` and a function which turns values of type `x` into values of type `y`, but these are definitions, and there is no way to capture the true process of applying the function to the value -- just another declaration of another function which has type `x → (x → y) → y` which is by itself never involved in a process.)

(As an amateur physicist, I hasten to remind everyone that Zeno won in the end; there is a context which Zeno could have never foreseen where a Zeno paradox makes a certain kind of motion impossible. The reason nobody can travel faster than light is that if you take your spaceship and try to race a light beam, first you throw down a beacon, and then you accelerate to speed c/2 relative to that beacon -- in your shiny new reference frame, due to the constancy of the speed of light in inertial reference frames, the light beam is still moving at speed c away from you.)

> Regulators have been cracking down on the industry’s misdeeds—most notably, lying about job-placement rates.

One of the services that my company (IntegriShield) provides is collecting these placement statistics; it is one of the less-profitable things we do, the sort of grunt work that you'd usually offload to a call center, but we insist on Doing It Right. It's a messy business: usually contact information is sparse and incorrect, and graduates mostly just let calls go to voicemail rather than give us 5 minutes of their time, possibly because they hear "we're calling you on behalf of <your university's name here>" and think "we're calling you about your student loans" or so, which we're not.

I guess my point is, I'm totally unsurprised that less-scrupulous employees faced with that hairball just said, eh, I'll make up that I successfully contacted them, what harm could that do? -- and if that happens, you've got across-the-board confirmation bias going on, "of course our graduates land good jobs in the field."

> a 2010 undercover government investigation of fifteen for-profit colleges found that all fifteen “made deceptive or otherwise questionable statements.”

Yep, that's another service we offer: we'll call your admissions reps undercover and see if you lie to us. Then you can retrain admissions reps to scale back or remove those claims.

> For-profit colleges have capitalized on our desire to make education more inclusive.

For chrissakes, don't blame the for-profit colleges for this! They did what any company does: they stepped into a business void. Your typical for-profit might be a barber/hairstyling/cosmetology college; they don't do anything that an apprenticeship at a similar business didn't already do; they just made it their raison d'être. The business gap existed because the apprenticeship normally takes a while and can't be done by dilettantes (people who have other jobs going on in their lives).

What really happened was that the economic recession led to lots of people being laid off, and some of those people had always wanted to move into a more-artistic service industry instead. They funded this training with government-issued student loans, which unfortunately have draconian legislation on them (like they can't be discharged in bankruptcy, the government doesn't even try to audit where the money is going, etc.). Still, the people who took these loans in theory were taking an informed risk; there's been no scandal about "nobody told me how much tuition was until after I graduated;" nobody's been fleeced.

Yes, there is some chicanery about for-profit colleges making the dream seem too-good-to-be-true (especially with regard to graduate placement). Combined with aggressive marketing that encourages people to dream big, there may be a valid complaint that they're overtraining the population so that more people are qualified barbers than any city legitimately needs, so that job prospects bottom out alongside wages. But they didn't provide the dream and they didn't provide the loan, they just inserted themselves in the middle, to take the loan money and service the dream. A voice of wisdom saying "hey, are you sure you want to drop everything for this dream? You're going to be in debt for quite some time if you take this loan" would be nice but it's also supererogatory: capitalism doesn't usually breed such saints.

After I wrote my "nermal" project (npm-installable JS authenticated-encryption container) I wrote a password manager as an example, which I called "tagaloop". Some documentation for it is available here:

https://github.com/drostie/nermal/tree/master/examples

In particular, I avoided the command-line interface precisely because the other tool on that page, ncrypt, would tend to leak inline passwords and such to log files. For various reasons those options were necessary to perform the job it required (e.g. in a script which is chmod root 500, for example) but not required for its use (it will just prompt you for the info if you leave the flags off).

In particular, the -a "add" option in Steel will probably save passwords to ~/.bash_history, no?

Because the timescales that you're "moving" on are very long from a relativistic perspective. If we localize you in spacetime you're maybe a meter long in one direction, two meters in another, half a meter in a third, and... 30,000 km in the fourth. If we look at you on the nanosecond timescale that you need to see time as "meters" we find that except for, say, electrons' worldlines about the nuclei, your worldlines are very much all parallel to each other.

Speaking as a physicist, I in general like this article, however there is a nasty technical point to make, which is that if you actually use distance units to measure time, we look like the "inanimate object, simple pattern", not the "living object, complex pattern." Moreover the "death, disintegration" slide is not going to be what you look like unless you happened to be in the vicinity of a bomb at your death.

Still the question of how we reconcile our sense of ourselves as speech-act-performing free-will-having conscious-feeling observers embedded in a changing world, with a relativistic perspective which says "there probably isn't one constantly-updating 'present' because a 'present' can be any hyperplane between two light cones, and therefore we can never have any physical basis to choose one as the correct one," is one of many really important philosophical questions that I think are important, though not really my domain.

So a quick summary of the ruling:

This was a movement for summary judgment which requires a very high standard: they are basically responding to a threat of a lawsuit by asking a judge to declare in advance that this lawsuit can never truly happen; effectively they are asking a judge to affirm that the threat is really, truly BS.

They gave a lot of reasons why the lawsuit might be invalid from the get-go, from "how do we know that the purported author was actually the first to write this?" to "how do we know that she didn't abandon her copyright interest before the critical date?"... but for a summary judgment, you don't need to show what's true but rather what's arguable. The judge denies the vast majority of these complaints by saying that even though the plaintiffs might have given some good evidence that those things are what happened, they didn't show that it was inarguable.

The sticking point is that the copyright today is only on the words, not the melody and various arrangements, which have long since passed into the public domain. However, according to the judge, there is absolutely no evidence that the copyright for the words was ever transferred to that company alongside the words. References to the various lost agreements between the parties generally explicitly say that they were agreements to transfer the music, and make no explicit mention of lyrics; and the lawsuits that the company began litigating similarly complained about the use of melodies or arrangements rather than complaining about the words being used. On this one narrow point the judge said, "no, that's inarguable: there is no argument that in all of this evidence you've brought me, that there is nothing transferring lyrical rights to the company.

Related: Real Men Don't Play GURPS: http://www.zipworld.com.au/~hong/dnd/realmen.htm (slight trigger warning: the "Real Men use swords to..." list ends on a line which can be read as quite rapey, though I don't think it was intended that way.)

(Note: it is a Windows-1292 document, correctly identified that way by a <meta> tag, which is incorrectly given a UTF-8 charset by a Content Type header. Therefore if the weird symbols are too distracting, you can save it to the hard drive and load it into a browser from there, and the symbols will resolve properly.)

It is worth reading for the line, "If you can't do it with a sword, do it with a fireball. If you can't do it with a fireball, it isn't worth doing."

This experiment should neither prove nor disprove it. It measures a parameter of a phenomenon (neutrino oscillation) which is well-known and which is only weakly affected by the premise that neutrinos are Majoranas.

So, just as a quick overview, there are two ways within the Standard Model to give a particle mass, one is the Higgs mechanism where the particle couples with a field generating an effective Dirac mass; another is to sum up certain Feynman diagrams (loops and other particles and such) generating a Majorana mass. These Majorana mechanisms effectively require that the particle be a charge-neutral fermion, so bosons (force-carriers) are out, as are quarks, electrons, muons, and taus. That leaves the neutrinos as the only known particles which could get mass this way.

For a while, it wasn't even known if neutrinos had mass; we now know that they do, but it's (m) at a scale much smaller than any of the known masses (M) of the Standard Model, and just postulating, "hey, the diagrams work out just right so m/M is a small number" feels like a cop-out. So one of the most intriguing Majorana-mechanisms is the so-called "seesaw mechanism": this postulates some symmetry breaking between the left-handed neutrinos of the Standard Model and some new right-handed neutrinos; the left-handed get ratio m/M and the right-handed I think get ratio M/m and it all sort of balances out.

There are two clear "signatures" that neutrinos are Majoranas: one would be to observe these huge right-handed neutrinos. The other is to observe two neutrinos perfectly annihilate.

What I think you're thinking of: In the early 2000s there were claims that experiments had observed the latter. This is a little tricky and the process is called "neutrinoless double beta decay," since a beta-decay produces an antineutrino and two antineutrinos can only annihilate if they are their own antiparticle.

The general consensus now is that those early experiments weren't sufficiently reproducible and we've never seen neutrinoless double-beta decay. However, that doesn't shut the door completely since double-beta-decay is already pretty rare: 76-Ge for example decays via double-beta-decay into 76-Se with a half-life of 10^21 years, or a hundred billion times the age of the universe. The GERDA experiment has been studying this stuff and can conclusively say that the half-life for neutrinoless double beta decay must be at least 10^25 years, and they're looking to increase their resolution to 10^26 years: so it's less than 1/10,000 of their decays observed so far, but they can capture it if it's more frequent than 1/100,000.

Well, harmonic drives are cycloid drives that use elasticity rather than eccentricity to do the same task, so let's focus on cycloid drives.

It's not quite the same your typical cycloid drive, but it has a strong relationship. Cycloid gears are about having an inner circle of radius A rotating within an outer circle of radius B by putting the center of A's circle on its own circle of radius C = B - A.

If C is small, then a fast rotation of C produces a slow off-center rotation of B relative to A. Since it's off-center, usually a bunch of holes (theoretically also of radius C, I think?) are drilled in B and filled with "output rollers" which connect to one single shaft which is on-center relative to C. Thus C connects on-center to this asymmetric B, which connects to an on-center output shaft that otherwise rotates as B does.

In his case, these holes don't exist and the rotation is never on-center. But you can use the same mechanism to convert his amateur cycloidal drive to one that has an on-center rotation of the input shaft.

Now normally in a cycloidal drive, A is regarded as fixed, while C is rotating, and B is still. In this case his C is totally implicit, his B is rotating, and he is at two different A's which rotate relative to each other. There are therefore presumably two different Cs, too.

It's hard to really isolate the exact mechanism in terms of connected cycloid drives. It is not as simple as fixing C and watching a single cycloidal drive's A rotate as a response to a rotating B, because that would have the reverse mechanical advantage. It's also not obviously "two cycloidal drives connected together by C", which would have a mechanical advantage near 1.

So I'm not sure what it is, but I don't think you can just say "oh, it's a harmonic drive."

I've read this comment three times and I still can't figure out what you're trying to say. It sounds like you're arguing that all "puzzles" should exist on finite domains so that a brute force solution exists.

"(x, 2x, 4x) gives you a "yes" every time, therefore it is a correct answer, at least as automatically checkable."

Well, no: you can type 1, 2, 3 into the system and it will tell you "yes", but your rule says that it should tell you "no".

It is crucial to the definition of "correct answer" here that your rule should not just say "yes" only for tuples which the widget also says yes to, but also your rule should say "no" only for tuples which the widget also says no to. That is what the puzzle means when it's asking, "can you guess the rule that we've created?"

This makes it very, very different from what I think you're thinking about, which is situations where someone tells you, "what is the next number in this sequence? 4, 7, 13, 25, ...?" where technically there are an infinite number of rules which will generate those 4 numbers first and an arbitrary number afterwards. Technically one of them is "simplest" in the sense that it can be expressed in 7 symbols, but in general it's a complicated problem and there is no best solution.

"To find a 'no' you're reduced to random guessing. That's not a puzzle, that's crap."

In many ways it still is a puzzle but the space that it lives in is richer. If you think about typical "puzzles" they're things like: "here's a grid with some spaces filled in with numbers,

    2 . . 2 . 2 .
    . . . . . . .
    1 . 3 . . 2 .
    . . . . . . .
    3 . . . 2 . 3
    . . 2 . . . .
    . . . . . . .

Each number is a block in a block wall. We want you to turn this into a block maze so that each 'block wall' (set of blocks connected by adjacency) contains exactly one numbered-block whose number says how many total blocks are in the wall. Furthermore the path (non-block space) of the block maze should be connected and should not contain any 'rooms' -- that is, any 2x2 or larger segments of open space."

This 7x7 grid has 10 spaces which are known to be blocks and exactly 12 more blocks scattered in the remaining 39 spaces, so just by those factors alone we're searching only (39 choose 12) ~= 3.91 billion possibilities; we can also use a quick heuristic to identify 6 places which must be "space" to break apart adjacent numbered walls, removing 91% of that search space.

The puzzles, "I have a set of integers where inclusion in the set is governed by a short rule, you can ask me any integer and I will tell you whether it is in my set", by contrast, have an infinite search space. This means that any solution is going to be more interesting, as will the means for checking that solution's validity. You could require, for instance, a Haskell expression of 140 characters or fewer which turns a nonnegative Int named `n` into a Bool, to be judged as "valid" or "invalid" if it properly filters `[1..10000000] :: [Int]`. You could even give the first 100 numbers in the set, e.g.:

    ghci> take 100 $ filter trueFn [0..]
    [2,5,8,9,13,14,18,19,20,25,26,27,32,33,34,35,41,42,43,44,50,51,52,53,54,61,62,63,64,65,
    72,73,74,75,76,77,85,86,87,88,89,90,98,99,100,101,102,103,104,113,114,115,116,117,118,
    119,128,129,130,131,132,133,134,135,145,146,147,148,149,150,151,152,162,163,164,165,
    166,167,168,169,170,181,182,183,184,185,186,187,188,189,200,201,202,203,204,205,206,
    207,208,209]

In this case that's pretty much enough to see the general pattern; the verification covers 10 million bits while the 140-character limit probably limits your search space to 1000 bits or so, so it's going to be hard to get an "incorrect" answer which agrees on that subspace of the whole.

Why? Nuance is certainly feasible.

What happens if you accidentally install NTP publicly, creating a public DDoS reflector? When it gets used, you get emails from people who are getting DDoSed by your IP, saying "hey, some attacker is using your system to compromise me." Now there are selfish and altruistic motives, both, invoked by that feedback, causing you to ban inbound NTP requests. Even if your server responsiveness doesn't matter much to you, you'd still like to limit legal liability; even if legal liability doesn't matter much to you; you still feel offended that someone else is twisting your systems to nefarious purpose.

So one nuance is that SAV doesn't really offer any feedback for the network operators: nobody from the outside ever complains so nobody from the inside ever hears about the problem. Maybe altruism is only economically viable with a good feedback mechanism.

Bjorn Lomborg is a sad case. He titled his book The Skeptical Environmentalist and everyone got the message, without reading the book, that he was a climate-change skeptic -- and for the most part labeled him as an "enemy" and rebuffed him. It was just a public relations disaster.

For what it's worth, he's not a "skeptic" in any of the conventional ways. I also remember looking at the IPCC reports once when I was a young physics student and saying, "hey, it's only a couple degrees Celsius over many years?" I was educated enough to realize that you could predict bad storms etc -- what I like to tell people right now is that it's like having a really huge boulder and, right next to it, digging a little ditch, only to cause the boulder to smack you down: the small change in the height of an equilibrium can still have a huge effect if a big enough system is relaxing to the new equilibrium. Someone came up with a memorable name for it: it's less of a concern about "global warming" and more about "global weirding." It took me a while to appreciate that there is a small (but scary) probability that the slope that the boulder is on might have a net incline one or the other way, so that the boulder might not just hit us but roll over us if it gets disturbed far enough from equilibrium. It makes a lot of sense for there to be a big scientific research program about that, even though no IPCC model predicts runaway climate change because the probability is so low and the possible causes are typically unexpected.

With that said: though hurricanes, floods and tornadoes certainly can have a massive economic impact, Bjorn has a good point of "the weather disasters that we know will happen due to the warming that we know is happening are important, but let's figure out how this compares to other things which we can predict really well, and see where our money is best spent: climate-change relief efforts, or climate-change mitigation, or general alleviation of poverty, or what?"

What I think is most missing from all of this is: we're talking about so little money, especially if we compare to governments' military expenditures, going towards the science. What would be great is if a government said, "hey, we're putting forward this huge grant to climate change research just because we think research is intrinsically good and want to support this huge project of, y'know, knowing more."

I think you can do it, but you'd probably want to start with density matrices, or use the Heisenberg picture to keep your wavefunction super-simple. If we're talking to geniuses then maybe we can include a one-off statement, 'if det ρ = 0 so ρ = ψ ψ† for some "column vector" ψ, then the squared magnitudes of ψ's components are probabilities to be in that component's corresponding state.' to get the gist of it.

I did cut him off. That's not a crime, but it was definitely a dick move. It was 2 AM and had it not been so late I'd probably have been nicer and just waited. (He might have been hoping that he'd caught a drunk driver?)

I don't think I 'failed to yield' to him because I exited the intersection before he entered it: he only really had to slow down once he got into the road I was in. But had he given me a ticket for that, I might have just taken responsibility and paid the fine. I mean, I think I could plausibly argue the case in court because I "made it" well ahead of him. But then again, he may have started slowing down much sooner, and it could be a thorny argument.

What interested me most about it at the time was: it was a 3-way T-shaped intersection formed by taking a 4-way intersection and blocking off the North end with construction work. So the North-South road had no signs, but the general rule for such intersections (and I think it's explicitly written down in most states, but I'm not sure) would be that the South traffic has to yield to East/West traffic: in other words, in combination with the East/West stop signs, I think the law-books would imply that the road should have implicitly become an all-way stop.