两种做法

一是用 minheap，在 Java 里就是 PriorityQueue，O(logn) time, O(k) space

``` java
public class LargestKIntegers {
public class TopList<T extends Comparable<T>> {
private final int _capacity;
private final PriorityQueue<T> _minHeap;

public TopList(int capacity) {
_capacity = capacity + 1;
_minHeap = new PriorityQueue<T>(capacity);
}

public void add(T nextValue) {
_minHeap.offer(nextValue);
if (_minHeap.size() >= _capacity) _minHeap.poll();
}

public Collection<T> getTop() {
return new ArrayList<T>(_minHeap);
}
}

@Test
public void keepLargest5() {
TopList<Integer> list = new TopList<Integer>(5);
for (int i = 0; i < 10; i++) {
list.add(i);
}
for (int i = -1; i >= -100; i--) {
list.add(i);
}
Collection<Integer> rst = list.getTop();

Assert.assertEquals(5, rst.size());
for (int i = 5; i < 10; i++) {
Assert.assertTrue(rst.contains(i));
}
}
}

```

第二种做法是类似 quick sort 里面的 partition


``` java
// Use partition in quicksort
// Expected: N + N/2 + N/4 + ... = N
// Worst-case: N^2
// Side effect: largest K integers will be in [K... N-1] subarray
public class KthLargestElement {
public int kthLargestElement(int k, ArrayList<Integer> numbers) {
int rank = partition(numbers, 0, numbers.size() - 1);
while (rank != k) {
if (rank < k) {
rank = partition(numbers, rank-1 + 1, numbers.size() - 1);
} else {
rank = partition(numbers, 0, rank-1 - 1);
}
}

return numbers.get(rank-1);
}

int partition(List<Integer> a, int s, int e) {
int j = s;
int midVal = a.get(e);
for (int i = s; i <= e; i++) {
if (a.get(i) >= midVal) {
int tmp = a.get(j);
a.set(j, a.get(i));
a.set(i, tmp);
j++;
}
}
return j;
}
}
```

方便之处在于，

1. 传递同一类对象。你自己也说了，只要是IAnimal，无论是DI也好，new也好，无论是单个animal还是一群animal都可以同过这个 IAnimal 从别处传递过来。否则一堆相似的类传进来，用不同的类型接，很冗余。
2. 对同一类对象执行同样的操作 e.g. foreach loop，

foreach(IAnimal a in animals) {
a.doSomething();
}

这样就省去了一堆相似的类却要写好多个 foreach loop

Java 7 开始有 diamond operator

List<Map<String, String>> child1 = new ArrayList<Map<String, String>>();

就变成了

List<Map<String, String>> child1 = new ArrayList<>();

稍微好一点儿。。

写文章这么好玩的事情，想写写，不想写拉倒。。。有时间就写，没时间拉倒。。。

同样的问题，大家的观点不一样、重点不一样，你用你的视角写总有你的价值。毕竟我们学习知识的时候来源并不是单一的，需要 cross reference：东看看西看看，才能看出问题的轮廓；复杂的问题，你解释一点、他解释一点，看的时候才能发现，总有一款适合你。

Markdown 不适合做笔记，因为很多时候你需要独特的排版来表示某些知识/突出某些知识点的重要性，并不是所有的知识生而平等。而且 markdown 加图不方便，手机上编辑也不方便。

Evernote 的 sync 功能就是渣，亏我还付了钱。

Onenote 很好，但是除了Surface能手写画图，没有觉得其他有好的地方，所以一般是用 Surface 画图后帖到 doc 里面。

现在做笔记用 Google Docs 和 MS Office Word Online.

自己的归类是，如果知识对别人有用，且值得为之写一篇完整的文章，则发博客；对别人没用或者我自己想保密，就放笔记。

最终等到分门别类积累到一定量之后，可以单纯作为笔记发布出来。

Code Complete +1

同为写 Java 的，不知道 Java SSH 的缩写是何物。。。原来还有这种缩写习惯。不过，web framework 这种东西的基本目的，不就是应该随便找个会写代码的即便不懂也能分分钟写 dynamic websites 么？

凡是小众的东西，统计上讲普遍使用的人教育水平会高一点。

可以看下 code complete 或者 Google 的 coding style guideline

coding style 有点儿乱

少想那些没用的，该学的都得学。

Facebook TAO 把 cache 用得出神入化，也值得一读。

KV Cache的本质是为了 Reduce latency for accessing active data，把常用数据的数据库的O(logn)的读写和复杂的查询变成O(1)的读写，cache的设计有很多pattern，常见的有 read-through/write-through(or write-back) 和 cache aside.

在分布式系统中，这些 pattern 的组合都是 consistency, availability, partition tolerance 之间的 trade-off，要根据你的业务需求具体选择。

## read-through/write-through(or write-back)

- Read-through: clients 和 databases 之间加一层 cache layer，clients 不直接访问数据库，clients 通过 cache 间接访问数据库。读的时候 cache 里面没有东西则从database更新再返回，有则直接返回。

- Write-through: clients 先写数据到 cache，cache 更新 database，只有 database 最终更新了，操作才算完成。

- Write-around: clients 写的时候绕过 cache 直接写数据库。

- Write-back: clients 先写数据到 cache，先返回。回头将 cache 异步更新到 database.

一般来讲 write-back 是最快的

## cache aside pattern

Cache 不支持 Read through / write through 的时候用 Cache aside pattern https://msdn.microsoft.com/en-us/library/dn589799.aspx

去哪上学都是浮云，关键是，无论去哪都要好好刷题。。

美国和中国的计算机专业，在我看来关键的不同是：

1. 作业。美国重实践重编程 coding assignment 很锻炼人，中国重理论重考试。
2. 视野。美国顶尖的计算机系，讲课的重点内容很可能就是教授研究的领域最前沿的内容。

两者合在一起，就是你的作业可以是直接上手改开源的工业界系统的代码，比如把某一个模块的某种算法换成另外一种算法，然后测试性能的变化。

当然无论在哪都有上课念PPT的教授。。。

少年你无论去哪，都要明确自己能力的边界，有比较清晰的学习路线图，高远的目标，并为之快乐地反复练习。

OAuth2 没有看上去那么简单，我不是特别的懂，但是可以说两句。

本质上来讲，**传统的 Login with Username/Password and create a stateful session with Cookies 的机制并不完美，它并没有考虑到 Client 可能是不可完全信任的**:

1. 无法安全地处理好 Clients 的授权粒度(Authorization with granularity for clients)的问题。
2. Clients 会知道用户的 username/password

而**OAuth 2.0 解决了对 Client 的信任问题**

1. User/Client/Authority 不同层级上的不同组合，达到更有粒度地控制对资源的访问
2. username/password 与 client 的分离: App 本身并不需要 username/password。用户能够取消某一 App 的权限而不影响其他 App , 用户改变 password 不会影响到App。

OAuth2 还有其他很tricky的地方比如如何防 CSRF。

在这里，我觉得 client id ， client secret，access token，等等一系列被盗了也没关系，因为你仍旧需要 用户输入 username/password，而且他们是有时效性的，bear token expired 后需要新的授权，仍旧需要重新输入。

既然不是 RESTful API，就老老实实叫 HTTP API，不用赶时髦。

用qt写分布式系统 http://zoo.cs.yale.edu/classes/cs426/2014/

Evernote 的跨平台实时同步问题极其严重，严重到不能用的程度。

onenote的好处是可以用笔，所以现在是gdoc文本+evernote画图。