happyhappy

This doesn't look very idiomatic, with assert() and __int__ etc. Please don't try to learn Go from this.

Edit: to be a little more constructive, do the Go tour instead.

I wondered the same thing. Noise in the picture should also make it extremely hard to predict. For cryptographic use one would only need 256 bits of entropy to seed a CPRNG, and I can't see how this amount of entropy wouldn't be present in a normal photo.

Telegram should be considered insecure. See this post for a nice summary: http://security.stackexchange.com/a/49802

Interesting product. Have you considered writing an output plugin for Heka (https://github.com/mozilla-services/heka), so that people could use the parsers and client side aggregators etc written for Heka with your service?

"In fact, Tetlock and his team have even engineered ways to significantly improve the wisdom of the crowd"

Does anyone know what these methods might be?

If I understand your question correctly, you should look into PAR2

I'm very interested in this. Can you name some of these strategies?

That is my experience as well. In my thought experiment the 'offender' would be a server instance, not a process running among other applications on a single machine. Applications that hit swap often have memory leaks, and hitting swap is then just a matter of time. Creating a cascading failure may be preventable however.

If you hit swap, again only the offending application or instance is punished, not everyone else (for instance by pummeling a backend database server that other services are using as well)

I've been thinking about something similar. I don't see how timed expiration would conflict with the two most important features - the filling mechanism and the replication of hot items. Am I missing something that would make timed expiration impossible?

Read the article for reasons for using groupcache.

That much is obvious.

If you have a bug in another application on the server running the cache that causes it to grow its memory use, your cache would suddenly disappear/underperform, and the failure could cascade on to the system that the cache is in front of. If instead you let the offending program crash because the cache is using regular memory, this would not happen. Just a thought.

Values that must expire could perhaps use a truncated time value as part of the key? It's not as flexible as regular expiration, because the entries would only expire when you cross the point in time where the truncated time value changes, which could be a problem in a lot of applications (sudden surges of requests every x seconds)

I want to use this, but since the keys are immutable, how can I store data like sessions which can change and would sometimes have to be invalidated from the server side (i.e. you can't simply change the session ID in the cookie and use a new cache entry, because bad-guy could still be holding on to an old stolen session ID)?

In general, how can one learn to think in an immutable fashion to effectively exploit this?

He seems to suggest that pot has a calming effect vs PCP

Your personal "objective" opinion? Kinda shows your own way of thinking.

What other time source would you propose using?

Can we get a manuscript? I'm from Europe, and I find this painful to listen to.

Being Nordic, I have no idea what you are talking about.