HN user
I'm a Microsoft employee, but I speak only for myself.
I think it is pretty hard to compute the cost, because what's the counterfactual? Even if you don't force a shutdown people may still opt to isolate themselves and businesses may opt to close, and the degree to which they do so is probably dependent on the dynamics of the pandemic, so you're going to be pretty sensitive to modeling errors.
So if you know of 10 different events which may occur with probability 10% each, you would prepare for exactly one of them?
I think it's clear that there are some events that may be rare but which are cheaper to plan ahead for than to deal with after the fact, and vice versa (e.g. for many people self insuring against minor losses like appliance failures makes sense).
But we can all aspire to be a >1 developer, even if we're not one currently. I don't necessarily think that contentment with being below average is universally bad (maybe it's perfectly rational given one's preferences for leisure vs. work, for example), but I'd hope that most <1 developers are juniors who hope to improve over time.
Yes, there has been some study of this phenomenon: https://en.wikipedia.org/wiki/Countersignaling
But writing code is only a small part of a software engineer's job (at least that's true everywhere I've worked), so selecting people who have opted to dedicate their lives to only that portion might be a worse idea than hiring better-rounded candidates, when it comes to building real software systems that need to be liked by users.
See also pure type systems
word2vec[0]:
computer programmer
- man
+ woman
---------------------
= homemaker
I would certainly dispute that programming time is necessarily slowed down. Ironically, I find myself thinking much harder about types in a dynamic language, precisely because there's no compiler there to do the rote work for me. Lately I've been using pandas dataframes quite a bit, and the number of hours I've wasted due to problems with types is mindboggling.
I think most do... Can you point to some that don't?
While it may be true that 50% of papers are wrong in some fields, the papers that are wrong are probably not the most highly publicized ones or the ones in the most prestigious journals (and when those papers are wrong the incentive to publish corrective papers is high), so this probably isn't quite as big a problem as it's made out to be.
I've more often heard "inherent complexity" called "essential complexity".
Vesa Karvonen posted a complete solution in SML here[1] (but LtU seems to be down so the link doesn't work), which I transliterated (directly, not idiomatically) to F# here[2].
No, see Brownback's Kansas tax cuts for just one recent example showing that (at least in our current tax regime) lowering rates brings in less revenue.
These are linear types by analogy to linear logic[0], so the terminology dates to the 80's at the latest. In contrast to your accusation, I think FP folks rarely make up terminology, usually preferring to borrow liberally from neighboring fields of mathematics.
Note that for comparable performance, you probably need not only the network topology but also the training data...
Non-polymorphic functions of the type `a->a` trivially satisfy it, of course. Also, I think polymorphic functions are the most interesting case where you can't use twice as desired in an ML-like language, so it's too bad that despite the fancier type they don't work too well in MLsub. Here's another example that fails when I'd hope for it to succeed:
let one = twice (fun o -> o.x) { x = { x = 1 } }Though note that an even better type would probably be
twice : forall a,b,c. ((a->b)&(b->c)) -> a -> c
twice (fun x -> x::[]) 1
(rec a = (a list | int) list)
(int list) list
)What does that have to do with this topic?
In a toy economy that's definitely true, but the empirical results are mixed in the real world, where there are lots of complicated dynamics.
I like the way Scott Alexander frames the effect size. This is from the conclusion the blog post you link:
An important point I want to start the conclusion section
with: no matter what else you believe, antidepressants are
not literally ineffective. Even the most critical study –
Kirsch 2008 – finds antidepressants to outperform placebo
with p < .0001 significance. An equally important point:
everyone except those two Scandinavian guys with the long
names agree that, if you count the placebo effect,
antidepressants are extremely impressive. The difference
between a person who gets an antidepressant and a person
who gets no treatment at all is like night and day. The
debate takes place within the bounds set by those two
statements. Antidepressants give a very modest benefit
over placebo. Whether this benefit is so modest as to not
be worth talking about depends on what level of benefits
you consider so modest as to not be worth talking about.
If you are as depressed as the average person who
participates in studies of antidepressants, you can expect
an antidepressant to have an over-placebo-benefit with an
effect size of 0.3 to 0.5. That's the equivalent of a diet
pill that gives you an average weight loss of 9 to 14
pounds, or a growth hormone that makes you grow on average
0.8 to 1.4 inches.
Could you provide a rough cost-benefit analysis?
What's the link to the FDA?
Isn't your theory regarding roads directly contradicted by the history of the Interstate Highway System?
It's a term of art. From Wikipedia[1]: "In economics, an inferior good is a good that decreases in demand when consumer income rises (or rises in demand when consumer income decreases), unlike normal goods, for which the opposite is observed."
Ensembles of humans can outperform the average human, and in the same way an algorithm trained on data labeled by an ensemble of humans can outperform the average human.
Your particular example doesn't seem especially object oriented (e.g. it looks like a simple data type with a "smart constructor", which is a common pattern in, say, Haskell, too). But in any case F# supports both discriminated unions as well as normal OO design, while C# supports only the latter, so in that subset of cases that are better modeled by DUs F# will be strictly better, and in the rest of the cases it won't be worse.
But someone else could create a subclass breaking the invariants. It's possible to avoid this by making the abstract class's constructor private and nesting the two subclasses inside of the abstract class, but this is not idiomatic. If you have to work that hard then most people won't bother, while in F# it's very natural to create such a design.
How does this compare to miTLS[1]?
Idiomatic F# code also uses Option types. However, all .NET reference types have null as a possible value. While most F# types don't have null as a "normal" value, there's nothing to prevent null instances of these types from being created "abnormally" at the .NET runtime layer (e.g. values of F# types created in other .NET languages like C# that don't respect F#'s metadata annotations, or created via F# operators like Unchecked.defaultof<_> that implicitly use the .NET runtime's default value of null for reference types).
In practice this is rarely a problem, but the article is highlighting what you need to do when you want to (efficiently) check for these boundary cases.