toth

Tangentially related, but was not aware of the python package sacred that they used. Seems pretty useful for organizing data science runs.

This is a nifty paper. Also very cool is the proof without words that just happened to be in the same journal page as the last part of this paper.

> Wow, can anyone shed some light on how they time this? What sort of clock, I'm assuming its some fancy hardware that you use to benchmark at the 4 nano second level? Or do you just claim this and assume that no one can prove you wrong?

There are some expensive hardware solutions to capture all network traffic and timestamp it at nanosecond level. E.g.,

https://www.endace.com/endace-high-speed-network-recorders.h...

Ah, that would explain it! Was not aware Oberth effect was thing, thanks!

That's a great read, thanks for linking.

I am little peeved by the maneuver at the beginning of the story though. You cannot use a slingshot maneuver around the sun to gain speed relative to the sun - that's simple conservation of energy. I know Geoffrey Landis is NASA scientist, so hard to understand how he could get that wrong, but it seems he did.

If you leak tens of thousands of emails by hundreds of people that the senders expected to remain private you are pretty much guaranteed to find some that you can read as racist, sexist, homophobic, or whatever you want.

In an ideal world we'd have leaks of every group involved in the election: DNC, GOP, Hillary campaign, Bernie campaign, Trump campaign, Trump's tax records, Clinton foundation donor list, etc. However, having a subset, which was selected by some actor with ulterior motives, leaked is IMHO strictly worse than no leaks at all.

The question about about TOR? Sure, they could have used TOR, but that doesn't make them automatically untraceable. I am definitely not an expert on this kind of forensics, but in past cases the "smoking gun" pointed to by experts tends to be some sort of metadata (i.e., text files encoded using cyrillic character set), not an ip.

Also, there's been some claims that NSA and other agencies are running TOR exit nodes. Not sure if there's anything to it, but the point is state level actors have resources that nobody else does.

Besides, I am not sure what is your point. "Russian hackers would have covered their tracks, therefore it must not have been Russian hackers"?

Well, I would agree with you if the DNC leaks were accompanied by equivalent GOP leaks. Personally, I didn't find the DNC leaks that damning to be honest - I don't think the same standards of impartiality that you need for the general election need to be applied to how parties select their candidates. However if other people do find them damning it is information they should have. The rub is that I would be very surprised if there weren't similarly shenanigans from the GOP side, and if that's the case then if you let foreign actors select what gets leaked that's giving them a lot of power...

Well, even if it wasn't Russia that hacked the DNC (and now the Clinton campaign) it is still the case that someone did, and that's still reason enough to take the measures Bruce Schneier's advocates.

Also recommended are the two other articles in this series:

https://johncarlosbaez.wordpress.com/2016/07/04/large-counta...

https://johncarlosbaez.wordpress.com/2016/07/07/large-counta...

You are saying that static_assert would not trigger here, correct? That makes sense to me, but it's not what is in the proposal [1] - see the "Not proposed" section.

[1] http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p029...

You may be correct, and I certainly hope you are. But if that's the case then the static_assert behavior seems all the more puzzling. In particular if this code works, then you can roll your own "static_assert" that will not trigger from the not taken branches.

Opinions differ I guess. I would love it if

    if constexpr ( COND) { CODE };

would compile even if CODE only compiles when COND is true. There a lot of nice use cases for that, and that's how the static_if in D works.

You can still do this sort of stuff with template overloads, but it's much more cumbersome.

Hmm, it seems this constexpr if is much more limited than I realized then. If I understood correctly the code in the the body of the constexpr if has to be correct even if the condition does not hold. I.e., this code:

    template<typename T> 
    void func(T x) {
        if constexpr ( std::is_same< T, ClassWithMemberF>::value ) {
            x.f();
        }
    }

will not work if you pass in a type for x that does not have a member function f. Is my understanding right? If so, constexpr if is not nearly as nice as I thought...

I agree that constexpr if looks great. I am confused about the decision on how to handle static_assert. It seems that

    if constexpr (false) { static_assert(false); }

Will fail to compile because the static_assert will trigger. This seems strange to me, anybody have an idea what the reasoning here is?

Well, the point is that paying a stock dividend is equivalent to doing nothing. All that happens is that 1 share turns into for example 1.05 shares. Price per share should go down by ~ 5%, but total market cap stays the same. A rational shareholder should completely indifferent as to whether the company gives out a stock dividend or not.

For a cash dividend that's not true. Something real happens: the company has less cash afterwards (and the shareholder more).

There's a school of thought that says that the value of share should be the discounted sum of all future _cash_ dividends. According to it a company that only does share dividends should be worth nothing.

The function call is not being optimized out, it's being hoisted outside the loop. I.e., it is as if the code was written as:

    let result = flatuseStruct(outputData)
    for _ in 0..<iterations {
        assert(result == 8644311667)
        total = total + UInt64(result)
    }

The counter will still be correct, but you are not measuring what you think you are measuring.

You are correct. They would have to drop an axiom to hope to go from inconsistent to consistent. E.g., go from ZFC to ZF (drop the axiom of choice).

If ZF is inconsistent... I think that would make a lot of mathematicians panic.

The title is incorrect and very misleading. This is not "salary" for hedge fund managers, it's total income. I couldn't find the exact breakdown, but for the guys at the top of the list, most of the income is not compensation for being a manager, it's returns for the money they had invested in their own funds. It's not a coincidence that the guys at the top of the list are the ones that manage funds that had a good 2015.

To see a better breakdown look at the 2016 rich list at

http://www.institutionalinvestorsalpha.com/Article/3552805/T...

Note the following paragraph:

    In a year when roughly half of all hedge funds lost money, a
    number of frequent Rich List members are conspicuously missing
    from the ranking because their funds finished in the red.

So for guys previously in this list their "salary" for 2016 was negative.

That's true, but it's also true if you drop the "passive" part :)

Yes, you are right, I am wrong! That works just fine. For the record:

   template<typename T>
   struct OnScopeExit {
       OnScopeExit(T f) :  f_(f) {};
       ~OnScopeExit() { f_();};
       T f_;
   };

   template<typename T>
   OnScopeExit<T> make_scope_exit(T f) { return OnScopeExit<T>(f); }

And then you use it as

    auto x = make_scope_exit([]() { std::cout << "Exitced Scope!" << std::endl; });

Lazyness is a great virtue! Thanks for the suggestion on unique_ptr , it should be pretty useful for debugging!

I actually don't think there's a nice way of doing this without making the interface slightly more annoying. If you make OnScopeExit a template on a callable, then you need to give it the type of the callable explicitly on construction, which means that using a lambda becomes more annoying. I.e., you'd have to do it like this:

    auto f = []() { std::cout << "Exited Scope!" << std::endl; };
    OnScopeExit<decltype(f)> x(f);

The way unique_ptr does it is by using type erasure, which requires a virtual function call internally, just like std::function.

That is a pretty cool use. In practice though, it is pretty unreadable unless you wrap it in a macro or template, and if you are doing that you might as well just implement it yourself. Something like:

    struct OnScopeExit {
        OnScopeExit(std::function<void()> f) :  f_(f) {};
        ~OnScopeExit() { f_();};
        std::function<void()> f_;
    };

Which you'd then use as

    {
        OnScopeExit x([]() { std::cout << "Exited scope!" << std:endl; };
        // ...
    }

Love this part:

"Meta-Failures

2016 This darn CV of Failures has received way more attention than my entire body of academic work"

0.5% of the GDP of US ($17 trillion) is $85 billion, not 1 trillion.

And I don't know many westerners that would say that $951M is not a lot of money :)

That is kind of misleading statement. What quantum computers change is not how many operations per second you could do, but how many operations you need to factor large numbers.

I believe that Bremermann's limit should also apply to quantum computers, but you are right in that example given for breaking cryptography is way off if you allow quantum computers.

Well sure, but there is a much more direct refutation of the claim that no physical system can achieve human level intelligence: humans exist.

Not really. If we are inside a simulation running on some CPU in the "real world" and they move the simulation to a CPU that's half as slow, from our point of view nothing changes. From the point of view of whoever is running the simulation, it now takes twice as long to simulate a day, but the people inside it cannnot tell.

That is pretty amazing, you should definitely advertise it!