快车道 就是找到一个点， 可以让你花比较少的时间就可以不断的产生收益。
缓慢的致富需要有一个收入颇丰的长期工作。 缓慢致富是一个失败的游戏，他依赖于华尔街和你投入的时间
真正的黄金岁月是你的青春、充满活力的岁月
人生的目标不是在芸芸众生中苟且偷生，而是要在疯狂中寻找自我。
正视现实的自己， 我不是运动员， 也不会唱歌， 不能表演，我也没有名望也没有身体天赋，但我仍然可以变得富有。
我寻找的百万富翁，他们刚开始应该像我一样都是普通人， 没有任何的特殊技能或天赋，通过某种努力才成了富翁
人需要改变、重新定位
我给自己栽培了一棵真正的、硕果累累的摇钱树。这是一棵茂盛的摇钱树， 每天24小时、一周七天地创建财富， 它甚至不需要我花时间打理。它每个月仅需要几小时的阳光和雨露。
[原文] https://llimllib.github.io/bloomfilter-tutorial/
A Bloom filter is a data structure designed to tell you, rapidly and memory-efficiently, whether an element is present in a set.
The price paid for this efficiency is that a Bloom filter is a probabilistic data structure: it tells us that the element either definitely is not in the set or may be in the set.
The base data structure of a Bloom filter is a Bit Vector. Here’s a small one we’ll use to demonstrate:
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 |
Each empty cell in that table represents a bit, and the number below it its index. To add an element to the Bloom filter, we simply hash it a few times and set the bits in the bit vector at the index of those hashes to 1.
It’s easier to see what that means than explain it, so enter some strings and see how the bit vector changes. Fnv and Murmur are two simple hash functions:
Enter a string:
Your set: []
When you add a string, you can see that the bits at the index given by the hashes are set to 1. I’ve used the color green to show the newly added ones, but any colored cell is simply a 1.
To test for membership, you simply hash the string with the same hash functions, then see if those values are set in the bit vector. If they aren’t, you know that the element isn’t in the set. If they are, you only know that it might be, because another element or some combination of other elements could have set the same bits. Again, let’s demonstrate:
Test an element for membership:
Is the element in the set? no
Probability of a false positive: 0%
And that’s the basics of a bloom filter!
Before I write a bit more about Bloom filters, a disclaimer: I’ve never used them in production. Don’t take my word for it. All I intend to do is give you general ideas and pointers to where you can find out more.
In the following text, we will refer to a Bloom filter with k hashes, m bits in the filter, and n elements that have been inserted.
The hash functions used in a Bloom filter should be independent and uniformly distributed. They should also be as fast as possible (cryptographic hashes such as sha1, though widely used therefore are not very good choices).
Examples of fast, simple hashes that are independent enough3 include murmur, the fnv series of hashes, and HashMix.
To see the difference that a faster-than-cryptographic hash function can make, check out this story of a ~800% speedup when switching a bloom filter implementation from md5 to murmur.
In a short survey of bloom filter implementations:
It’s a nice property of Bloom filters that you can modify the false positive rate of your filter. A larger filter will have less false positives, and a smaller one more.
Your false positive rate will be approximately (1-e-kn/m)k, so you can just plug the number n of elements you expect to insert, and try various values of k and m to configure your filter for your application.2
This leads to an obvious question:
The more hash functions you have, the slower your bloom filter, and the quicker it fills up. If you have too few, however, you may suffer too many false positives.
Since you have to pick k when you create the filter, you’ll have to ballpark what range you expect n to be in. Once you have that, you still have to choose a potential m (the number of bits) and k (the number of hash functions).
It seems a difficult optimization problem, but fortunately, given an m and an n, we have a function to choose the optimal value of k: (m/n)ln(2) 2, 3
So, to choose the size of a bloom filter, we:
Given a Bloom filter with m bits and k hashing functions, both insertion and membership testing are O(k). That is, each time you want to add an element to the set or check set membership, you just need to run the element through the k hash functions and add it to the set or check those bits.
The space advantages are more difficult to sum up; again it depends on the error rate you’re willing to tolerate. It also depends on the potential range of the elements to be inserted; if it is very limited, a deterministic bit vector can do better. If you can’t even ballpark estimate the number of elements to be inserted, you may be better off with a hash table or a scalable Bloom filter4.
I’ll link you to wiki instead of copying what they say. C. Titus Brown also has an excellent talk on an application of Bloom filters to bioinformatics.
1: Network Applications of Bloom Filters: A Survey, Broder and Mitzenmacher. An excellent overview.
2: Wikipedia, which has an excellent and comprehensive page on Bloom filters
3: Less Hashing, Same Performance, Kirsch and Mitzenmacher
4: Scalable Bloom Filters, Almeida et al
My eyes crack open. 7am. Roll over. Grab my phone. Start scrolling…
Check Product Hunt. Ahh, shit. Someone just launched an app similar to my product (and we’re still in beta).
Scroll through Twitter. Shit! This person I’m jealous of just announced a another success.
Read Medium. Fuck. Someone wrote a post almost identical to what I wrote months ago and they’re getting more traction.
My envy grows large, my blood pressure goes up. I feel like I’m waking up in a heavy cloud; an agitated haze. Already on edge, and I haven’t even made toast yet.
Stress is our body’s defense against bad news. It was useful when our ancestors were running around the jungle about to be eaten. It’s much less helpful now.
The problem is that the worry itself can harm you as much as the outcome you’re worried about. While you’re stressing over what might happen, your body is releasing adrenaline and cortisol as if you were actually in danger.
These hormones are what cause intense feelings: jealousy, anger, sadness, despair.
But even worse, they reduce your ability to make great stuff.Instead of putting your energy into creating, you’re obsessing about things you can’t change.
Here’s how to get out of that negative downward spiral:
Agonizing over your competition doesn’t help you serve your customers better. Being jealous of your peers won’t improve your craft.
There’s only two things that will improve your situation:
Focus on your own shit and ignore everything else.
漫画家蔡志忠有一个演讲，题目叫做《努力是没有用的》。读完这份演讲稿，我觉得他说的有道理。
有些人非常勤奋，别人休息和娱乐的时候，都在工作学习。但是努力了一辈子，人生也没有显著的提升，就像报道里经常说的：”某某在平凡的岗位上，勤勤恳恳工作了一辈子”。
另一方面，很多成功者似乎也没有特别努力，就取得了许多成就，过上了好日子。蔡志忠以自己为例，他从小就喜欢画画，然后一直画，不知不觉就成了大漫画家，名利双收，从没有觉得过得很辛苦。
老师或父母老是说，努力就会走到巅峰—-才怪。如果这样，不是所有人都走上巅峰了吗？没有人开始不努力，为什么后来不努力，因为努力没有效果。”
人生不是走斜坡，你持续走就可以走到巅峰；人生像走阶梯，每一阶有每一阶的难点，学物理有物理的难点，学漫画有漫画的难点，你没有克服难点，再怎么努力都是原地跳。所以当你克服难点，你跳上去就不会下来了。
蔡志忠的核心观点就是黑体的那句话，成功的人生是台阶式向上，而不是一条水平线。努力只是说明你拼命在走，跟你能不能向上走，关系不大。那些努力却没有结果的人，根本原因就在于，他一直走在平面上，没有走到更高的台阶。
也就是说，垂直方向的努力更有意义，水平方向的努力意义不大。你把同一件事情勤奋地做上十遍，还是只会做这一件事；你做完这件事后，再去挑战更难的事情，就有机会学会做两件事。
初学者经常问我，前端开发应该学习哪一个框架？我的回答就是，你觉得哪一个框架比较容易，就用那个。因为它们都是解决同样的问题，你只要知道怎么解决就可以了，没必要深究哪一个解决得更好。对你更重要的是，要去解决更多的问题，而不是如何最好地解决一个问题。
只有通过解决更多的问题，人生才能摆脱水平运动，进入上升运动。当然，这里还有一个天赋和兴趣的问题，如果找到属于你的领域，不用特别努力就能上台阶；如果找不对领域，再努力也只能做水平运动。
用户的习惯和期待比欣赏更能形成强大的护城河。 成功的产品将持续的成功直到遇到大的变化或者管理上的失误。 一旦大量的用户对某一产品形成固定的习惯和满足上的认知， 那么让他们去转向一个新产品将会变得非常艰难，即使这个更好的产品。
The best product doesn’t always win. The one everyone uses wins. Later we all tell ourselves a story about why and how that product was really the best all along in an impressive display of survivorship bias. In fact, the history of technology is littered with quantitatively superior products that lost in the marketplace because they weren’t well timed, well marketed, or well supported: VHS vs Betamax. Gasoline vsElectric. English vs Esperanto. Metric vs Imperial.
“Habit and user expectation remains a stronger moat than people appreciate.” – Ben Thompson
Winning products tend to continue to win until major disruption or mismanagement. The reason for that is simple: everyone else has to conform before they can compete. You become the de facto standard against which other things are measured. It is hard to differentiate for the better when people have already collectively endorsed a fiction that the best solution has already been found (and, what luck, it’s the one that won). Society is a dynamic part of product/market fit, and once a large number of humans have learned come to expect a certain behavior, there just isn’t enough value in learning a new system even if it is better. This isn’t just about switching costs between products but rather more fundamentally about interaction paradigms. Do you really think an app garden is the apex of all possible phone UIs? Is a vertical scrolling feed really the best way to stay up to date on friends? Does the QWERTY arrangement on a keyboard make any sense today?
This is the reason companies focus so much on growth. It isn’t just that growth signifies a fit with a market. But rather because growth actually makes the market fit stronger. Even when the product doesn’t involve network effects directly it still benefits from the habits and expectations of the population at large that accompany growth.
[ source: http://boz.com/articles/growth.html ]