doomjunky

When it comes to risk management, the human brain that is bound by evolution to dangers close in time and location, is not capable of assessing the consequences of losing a piece of the planet earth's habitat for millions of years.

[0]: Milton Friedman https://www.youtube.com/watch?v=R5Gppi-O3a8

You could reduce the sequence ID space by employing the fact that it is overall less likely that a tweet is deleted than otherwise and a sequence of two CONSECUTIVE deleted tweets is even less likelier.

E.g. If you find sequence ID 0 but don't find 1,2,3 than you can probably skip 4,5,6,7. I don't know the probabilities of deleted tweets, but i am sure someone could calculate it to determine the 99% threshold.

2) There is no guarantee that traffic IS NOT routed from another region to handle traffic peaks.

http://taobackup.com/

The complexity is O(log log n), under the assumption of a uniform distribution of the data.

https://en.wikipedia.org/wiki/Interpolation_search

Functional programming languages have several classic features that are now gradually adopted by none FP languages.

Lambda expressions [1] is one such feature originating from FP languages such as Standard ML (1984) or Haskell (1990) that is now implemented in C#3.0 (2007), C++11 (2011), Java8 (2014) and even JavaScript (ECMAScript 6, 2015).

Pattern matching [2] is another feature that is now^2015 implemented in C#7.0. My bet is that Java and other will follow in the next versions.

Here is a list of FP features. Some of which are already adopted by none FP languages: Lambda expressions, Higher order functions, Pattern matching, Currying, List comprehension, Lazy evaluation, Type classes, Monads, No side effects, Tail recursion, Generalized algebraic datatypes, Type polymorphism, Higher kinded types, First class citicens, Immutable variables.

[1] https://en.wikipedia.org/wiki/Lambda_calculus

[2] https://en.wikipedia.org/wiki/Pattern_matching

https://en.wikipedia.org/wiki/Anecdotal_evidence

I took a seminar on the probabilistic method and my advisor recommended me to read this book. This book is for scientists. It lays out the foundation of the probabilistic method and a theoretic background.

< 30 Follow somebody. It's not which company you go, it's which boss you follow.

< 40 Work for yourself, if you realy want to be a entrepeneur.

< 50 Focus on things you are good at.

< 60 Work for the young people.

> 60 Spend time for yourself.

~Jack Ma's Advice to The Young People

Giving things away for "free" is a common marketing strategy to generate leads. A lead is a qualified contact of a potential customer. This things could be of a broad range of cheap assets, e.g. ebooks, apps or even games.

I have seen a marketer buying the copyright of a ten year old textbook for a cheap price, polishing it, giving it a new shiny cover and a new title containing up to date buzzwords, and then giving it away for a "free" subscription via e-mail, and on top asking the customer kindly to come up for the shipping. I wondered why i couldn't find this book on amazon or somewhere else, but then i understood that it was re-released on the purpose of being exclusive for subscription. The cost for printing a small number of copies (500 copies) is quite low ($1-3 per book). This is a decent price for a qualified lead.

This strategy has two benefits. First, you get a qualified lead with contact info and even with a correct address. Second, some countries have laws against e-mail spam, but this laws often have loopholes. In cases that your company has a business relationship with someone, you are allowed to get in contact and advertis your other products via e-mail, on an opt-out basis. Giving "free" assets to a costumer establishes this kind of business relationship. Almost always this "free" assets are of a minor quality, for me not sufficient enough to give away my datas.

Freemium isn't free.

The super-seeding / swarming approach developed for the BitTorrent protocol is quite interesting. One original seeder just needs to upload to a few leechers. Then this leechers become seeders themselfs and start to upload to a next layer of leechers and so on. This approach scales exponentially meaning you can cover the whole internet in just a few steps. Further more you can start uploading yourself even before you have completed receiving the file.

E.g. if every node just has 10 uploading connections then you just need 8 steps to cover 100 million = 10^8 peers. Remember the traffic on the original seeder (and every other node) is just 10 uploading connections.

https://www.kalzumeus.com/2010/06/17/falsehoods-programmers-...

Assuming the number in the right side are the spectators. Could you show on the left side how many peers are seeding?

In Visual Studio you can control this behavoir with the __cdecl, __clrcall, __stdcall, __fastcall, __thiscall, __vectorcall [1] calling convention function prefixes, but this also depends on the optimization options [2] of the compiler.

Passing arguments via CPU registers has a huge preformance benefit, but also some drawbacks.

[1]: https://msdn.microsoft.com/en-us/library/984x0h58.aspx

[2]: https://msdn.microsoft.com/en-us/library/46t77ak2.aspx

    // Just tested with mingw-gcc on Win8.1
    // Maybe you need to play around with the offset, +28
    int main() {
        int i; // Another stack variable

        printf("%d\n", (long long)&i + 28); // &argv
        printf("%d\n", *((void**)((long long)&i + 28))); // argv
        printf("%s\n", ((char**)*((void**)((long long)&i + 28)))[0]); // argv[0] 

        return 0;
    }

- Big companies are: More efficient but less flexible

- Small startups are: Less efficient but more flexible

Big companies are more efficient because every employee has a narrow field of responsibilities. They are dedicated to just a few tasks and can leveradge from focusing their minds on just one thing (e.g. a web developer who is just responsible for programming his mobule). Compared to a small inefficient startup, were every employee has a broad spectrum of responsibilities and needs to refocus his mind often (e.g. a web developer who has not only programming tasks, but also system administration, setup/deployement, UI design, customer support and cleaning the coffee machine and fixing the printer).

Small startups are more flexible because everybody can directly give new ideas to the boss, everybody has knowledge about the whole company and how everything is tied together and changes to processes or infrastructure can easily be adopted.

I think this situation is not a bad thing. Big companies and small startups live in symbiosis. Startups are flexible enough to produce new innovations. Then they either grow big (implement processes, standards, hierarchies, etc.) or get acquired by a big company. However, big companies are not flexible enough to produce new innovations but they have the resources to found spin-offs / create new startups.

   int x = readIntFromIO(); // -2147483648 to 2147483647

    if(x < 3) {
        // -2147483648 to 2
    } else {
        // 3 to 2147483647
    }

You can add assert() statements to your code for expressions (e.g. assert(x != 3) ) that you assume to be an inconsistent states and solver will give you test cases for this.

I suggest:

- "L9Pro840Of9KNI...This.entrophy.is.intentionally...GfKD4tf8tOwTG9Dcqj"

or even better

- "Dear support agent, DON'T reset my passwort on any security question!"

I also write "passport required" on top of all my bank saving books with a ballpoint pen.

- Developed by Microsoft

- Open Specification

- DHT-based

- IPv6 only

- Windows support since Windows XP SP 3

- .NET support since .NET Framework 3.5 (System.Net.PeerToPeer)

[1]: https://en.wikipedia.org/wiki/Peer_Name_Resolution_Protocol

[2]: https://msdn.microsoft.com/en-us/library/aa371699.aspx "PNRP Namespace Provider API"

[3]: https://msdn.microsoft.com/en-us/library/bb726971.aspx "Peer Name Resolution Protocol"