Bullshit asymmetry principle

What is really hard to recognize is bullshit that just "floats around" without single source.

Edit: I don't think I am qualified to say that, as I didn't live my second 10 yet

PS: Well you got to my no-BS list

A ton of the comments, disguising as good natured, that give more or less unqualified praise to these languages are actually mostly bullshit, eapecially two very specific strands of discussion, which are usually about Nim or Julia capabilities compared with Cython, and to a lesser degree sometimes Julia’s multi dispatch templating patterns.

It is so hard to wade through those comments and follow down every link and cultish argument or counter-counter-argument, meanwhile you’ve got people claiming that perfectly reasonable criticisms of those languages are themselves the “real” bullshit.

It turns into such a convoluted mess that everybody is certain that everybody else’s claims are the bullshit and that their own claims (which other people think are the bullshit) are genuinely refuting bullshit.

By the end of it, a strategy like yours becomes very hard because the time complexity of the research task gets intractable even for a small subset of claims.

Like literally once I had to go and read a ~30 page published research article to learn that a certain Julia differential equations library happens to use a particular multi dispatch templating pattern to offer a way to treat uncertainty modeling as a built-in, domain-specific construct, but that this was not some type of advantage of Julia or anything (since you could do literally the same thing at the same level of abstraction in Cython), and nor was it even a required aspect of the differential equation domain problem, it was just a sort of extra feature that worked out in that library, but which could be implemented (arguably more simply) without any of the multi dispatch behavior at all.

Blerg. I had to wade into all that, ten levels deep in some nested conversation with hard to believe one-sided support of Julia, all just to learn that one single point could be refuted!

Technology has lowered the barrier of bullshit much greater than the barrier to refute bullshit.

The specific mention is about uncertainty propagation in our differential equation solver library. It happened automatically because of the type system. There's evidence of the thread where we found out, since a user notified us that it works:

https://discourse.julialang.org/t/differentialequations-jl-a...

We have since been investigating the pharmacometric implications of this methodology and are seeing good promise in a paper that is coming out.

But then of course someone will come along and say "Cython can do it too". Yes, every Turing complete language can do everything. The point is how a 0 line of code feature led to a new avenue of research, and Julia's dependent compilation process allowed this to be a very optimized implementation. Of course, this little to no effect solution is pretty cool and something to share! However, as stated in the resource of this HN thread, bullshit propagates fast, so this other person had already come to this thread to start ragging on this work long before I could get here (since we were at a pharmacometrics conference getting feedback from the FDA about the uncertainty propagation algorithm! Just to show its real, check the dates of ACoP 2018).

So let me add a corollary to this principle: any sufficiently widespread work will have an anonymous disgruntled bullshitter that hates on it. I guess you're supposed to learn it's a compliment that someone runs around spending their time doing this to you. But hey... I wasn't going to respond anymore but the thread's focus was just way too perfect. See you next time mlthoughts2018: maybe the name will change soon to make it harder to bop the bullshit.

Simple: If a source has been found to lie apply a weight of zero.

1. Mostly speak truths.

2. Scatter your bullshit sparsely so it remains relatively difficult to detect.

3. Wrap your bullshit with caveats or innuendo so you can argue others misinterpreted you. When someone interprets your bullshit as bullshit, counter that they are bullshitting by intentionally misunderstanding your bullshit.

4. When you get caught in complete bullshit, double down on it with such conviction and fury that you convince people by force that it isn't bullshit.

I could try listing real life implementations of the above BGA, but it would likely surpass HN's character limit.

Having class libraries in NuGet did work well for us (we are open source).

Next trend to die soon: TDD / "Unit tests" that mock half the app

The way to go is to offer a compelling alternative.

Of course, this applies only if the bullshit has been confirmed as such and if the person promoting it has shown to be uninterested in a sincere and fair argumentative discussion.

Chewbacca defense https://en.wikipedia.org/wiki/Chewbacca_defense

See: Flat earthers, anti-vaxxers, and birthers.

Maybe an S operator for scattering bullshit.

Time independent Hamiltonian for Steady-State bullshit.

etc.