好快喔一年又过去了

新工作的进度条已经跑过了一年，19年不管是学习还是工作生活，都比以往的几年有了很大的改变，我从一个死宅，10分钟跑完一公里，变到能够参加2场完赛的半程马拉松，在工作中也接触到了更多更多的开发者，以及更多有意思的需求，2019年从0到1，学习react-native & flutter 移动端的跨端技术，并且参与了跨端sdk的贡献，也开始接触了Webassembly，做了一个h264的软解码器原型，开启了未知领域的大门，也算是对现代客户端开发的近距离触摸。从半吊子的ruby后端，转做了全职的IM切图仔。还有就是增脂了。

做生活的甲方？

某个脱口秀节目组曾有过一个响亮的话题：“做生活的甲方”。那到底要怎么做才算甲方？以前也在知乎，微博见过这样的字眼，然而我对甲方和乙方真的没有什么认知，直到了我成为了一个全职的“乙方”，才清楚的明白甲方是个怎样的角色，甲方和乙方在签订契约以后，甲方看重的更多是自己的荣耀和乙方能给它带来价值，乙方则会尽量按照契约去实现对甲方的许诺。本质上是一个可信赖的纽带关系。为什么脱口秀节目要说“做生活的甲方”？也许这就是当下的“三和dai神”的内心独白，做一天，玩三天，黑厂不去，吃饭只吃挂逼面，只去5块钱包夜的网吧，不去5块一小时的网咖，谁不希望呢？当生活的甲方，那么谁是我的乙方？难道花呗，借呗，微粒贷就可以是我的乙方？那生活真的是太棒了。对于我这种普通人来说，生活最大的敌人只有堕落，工作和生活平衡对我来说才是这个问题的最合解。自然如何平衡也是一个选择题，我可以选择做乙方，但也可以在乙方角色里适当的切换，找到一个生活的音节，把它串来成为自己的节奏，为自己打拍，持续的生存下去。当甲方很容易让我变得桀骜不驯，做出不正确的判断还活在自己的世界里，最后沦落5块钱包夜的网吧都进不去。当乙方的时候，我才会去反思自己以前的做事和处事是不是不够职业化，显得不够专业，不得以信赖，虽然这些是由个人因素造成的，但并不表明这是没法通过后天的训练和努力去改善。

开始跑马了

初遇大佬，我又又遇到了一个学医转行做程序员的大佬，在大佬的指导下我成功的从一名2019年年初10分钟跑完一公里的废宅，在几个月的努力下，完成了2场半程马拉松。第一次半程的经历实在是让我难以忘记，由于是第一次比赛，穿的不是训练鞋，加上个人比较兴奋，我在两公里的时候就已经跑崩了，心想大概是凉了，毕竟第一次嘛，也许我就不适合参加马拉松吧。但当我看到了一个和我一样情况的跑友，他并没有直接就放弃比赛，仅仅是降慢了速度，而且他的体型应该是我的1.5倍，没过一会儿人家就恢复了体力，直接远超了我，当时我十分的诧异，因为这个跑步姿势和体型，不太像是一个专业的运动员，普通人也能有这样的恢复能力吗？突然回忆起大佬跟我说的话，开始不要跑太快，也不要和别人抢先后，请找到自己的节奏，并且坚持下去，完赛才是最终目标。果真奏效了，虽然没跑到个人最佳成绩，但是和我预想的差不多，2小时28分完赛，第一场比赛在六老师（六小龄童）的故乡，刚好还是夏天，我和大佬在那边享用了一顿特别完美的皮皮虾大餐，也是人生中第一次吃到带黄的皮皮虾，而且黄特别足，味道一百分！这次的经历，让我更加相信，我是可以在大佬的帮助下，把自己往更好的方向改变。

我的跑步战绩

读完的书

• 菊与刀（这本也是同事的力推下读完了，因为个人对日本社会比较好奇，抱着学习的心态，但是作者的个人观点太多，以及作者并不是一个日本人，最终让我对这本书的评价很低）
• 精准努力（作者是一位金融从业者，表达了一个正常的企业是怎么决策和衡量价值的，有那种典型的日企思想，努力工作和精准努力工作，是两个不同的结果，尤其是在日企里。）
• 半小时漫画中国史（快餐读物，由于个人一开始对历史没有任何兴趣，加上生活节奏很快，个人时间分配不合理，导致我没办法细致的读完《中国通史》，只能先快餐文化开始，总体来说画风和语言都比较适合我。）
• 半小时漫画世界史（阅读体验同上）

这一年我主要参与维护的开源项目

声网的场景化IM

• https://github.com/agoraio-usecase/eEducation

声网的跨端SDK

• https://github.com/syanbo/react-native-agora
• http://github.com/agoraio/agora-react-native-rtm
• https://github.com/agoraio/flutter-sdk
• https://github.com/agoraio/flutter-rtm

2020年？

想了解这个世界的灵魂传承：历史文化，时代变迁，神秘科技。
希望可以跑玩2020年完华东地区的所有马拉松。
要学好英语，过雅思7！再学一门外语。
好好学习现代前端技术。要有个属于自己的长期维护的开源项目。要坚持写博客！
希望生活和压力可以合解。
加油！

2018的最后一个月

2018年的冬天比以往来得更早一些。空气中弥漫着寒冷的味道，匆冗的脚步随着呼吸声消失在街道的尽头。资本市场的气温也随逐下降，距离新的一年还剩不到一周的时间。

瞎扯淡

2018年，只有临近年末的11月，是我最清醒的一个月，我深刻的体会到了，被自己的预期和现实的生活之间的差异带来的沉重打击。
那种打击，犹如刚参加完田径比赛，然后气喘吁吁的停在终点，刚想抬头喘口气，此时被比自己瘦很多的选手撞上一般，这种措手不及的痛，随着撞击面积，逐步散布全身。
我是个很膨胀的人，总是沉静在过去的荣耀之中，曾经认为现在的生活，都是我自身牛逼才换来的，别人都是靠99%的汗水和1%的运气，然而实际上，我是靠99%的运气和0.10000000000000002%（被缩水以后的努力）。
我的爱好比较小众，更不爱说话，每次说话就要紧张，而且经常会让别人不能理解我的想法，也是和从小生长的家庭环境影响造就，我这样属性的角色，在游戏里一定是那种新手村被练级的小怪，上来就刀秒，刀刀都暴击。居然还能工作到第三年，感谢我一直以来能遇到能包容我的朋友，还有鼓励我的同事。很早以前混csdn的时候，有很多人说，程序员工作3年是个坎，我曾认为这是个技术坎，只要你努力一直在学习，跟着时代的步伐，就不会出现瓶颈，生活告诉我这是错的，我太关注按照市场去学习技术，没有去考虑如何做事，刚工作的时候，我觉得自己是个小兵，只要把自己的任务做好就行了，但是怎么做，中途遇到问题，怎么处理我都没有一些规范的习惯，导致我处处碰壁，靠自己坚强的蛮力走到了现在。然而生活还是要继续的，不管什么职业，什么岗位，我还是要和人相处的，我也没那个水平给自己做个AI女朋友，也没有办法处理父母的唠叨，没有能力不通过交流实现自己的想法，我需要去push自己，而不是迈出第一步。
感谢自己能一路连滚带爬的走到2018年结束，没有朋友们的帮助，我大概是没法这样完整的走过来。
2018年”学技术”，”码农”，”40岁之前退休”,”大龄”，”区块链”，”互金”这些词依旧是网络热点，甚至培训机构和各种综艺节目把所谓”互联网从业者”，”高端人才”捧的是风生水起，时间走得很快，时代变化的也大，很多人眼里，风口上的从业者，就算是猪也是社会中的精英。这种不良的风气已经深入每个社会人的思想上。
试问下那些眼红做技术的人，你们见过凌晨4年的写字楼么？你们接过半夜三点的电话嘛？你们知道如果某天AI梦实现了，这帮人还能去做什么养活自己？
都8102年了，网上还散播着，”我的成功是可以复制的”，”XXX正传”，请问你的成功要去哪里粘贴？为什么我找不到这个键，是不是我买的鼠标有问题？请问你的正传，是北还是南？为什么我找不到我自己的方向？每天新闻媒体都在曝光，那些成功人士的丰功伟业，收录那些XXX的获奖感言，文章开头都是以XXX的观点，作为上帝视角来发表，试问一下那些成功人士背后的人都去哪了？虽说人是要有信仰的，但是你信了一个疯子，那么和阿卡姆疯人院的各位大佬萌有啥区别呢？监狱才是你的归宿，肥皂才是你的人生buddy。
互联网让交流降低了门槛，快餐式文化在爆炸式的传播，这很容易让人膨胀，很多人总认为成功人士A说的话很有道理，但是又美中不足，自己一定能超越同类的成功人士B，并且还能实现异类的成功人士C一样的理想，还会误以为，这个操作可能一般人类还看不清，不能被短期复制和超越。是的，你的自我感良好，会让你摔得浮肿。说好的，”愿你出走半生，归来仍是少年”，你只迈出半步，结果肿成了猪。

总结

变化是不可预测的，我只有和现在一样，拥抱变化，适应环境。
要过得洒脱，不要被戾气吞噬，自愿成为奴隶。真正的自由不是叛逆，足够自律才能足够美好。真正的强大不是承受，足够的达观才能有钢铁般的身躯。
人这一生十分短暂，还是要多学习多尝试，不要沉浸在那些自己靠运气和时代而获得的奖励上。世界很大，资源很少。
人这一生能有朋友，也是一份值得珍惜的事情，不要以自己的利益让别人对你失去了宝贵的信任。
祝好。我的2019年。

rust的由来

rust最初是Mozilla公司（我们写前端的当然知道啦）的一位肥宅 - Graydon Hoare 的个人项目，后来公司在09年开始赞助项目，2010年被公布于世，所以说肥宅一定要多做个人项目，梦想总是要有的嘛，说不定哪天就实现了，成为万人瞩目的肥宅之王，成为Gayhub的明星程序员，被万人f**k，被肥宅圈粉。这大概是我们现代肥宅的最大梦想吧。

我和rust的情缘

说到rust很多人不陌生，这是2010年生产的一门新新语言，然而这门语言在我刚接触编程的时候(2012年)就已经听说了，当时加的某c++群的一个群友就在布道rust，只可惜当年的我还处于对力量一无所知，按部就班的学习主流的系统级语言，没有勇气和能力去探索。没想到六年后的今天，我终于觉悟了，封印解除，buff全开，打算好好驯养一下这位伟大的现代化系统级编程程语言。

肥宅 の Rust FIRST IMPRESSION

哎，这个标题是不是很眼熟呢？! 没错下♂面开始进入正题。
博主当前rust版本是stable 1.26.1，在macos下brew install rust会安装一个叫做cargo的包管理，cargo的包管理会按照一个叫做toml的文件格式，做相关的包管理，以及编译链接等功能。cargo是一个加入了rust standard的包管理，这对于以前手写makefile或者cmake等构建工具来构建c/c++环境，你只需要配置toml，然后简单的cargo build / cargo run 就可以编译连接并且运行rust程序，真的是一种解脱，（x肥宅快乐水再也不是我加班的动力，写rust就是肥宅的我最高快乐G点）。
你以为这样就满足了？naive。
让我们看看rust中的特性：
1.表达式和语句

1
2
3
4
5
6
7
8

fn expression_or_statement(a: i32) -> i32 {
  let mut b = a; // 由于rust中默认赋值之后，都是不可修改的，所以这里要用mut修饰符表示这是一个变量
  b = {
      let a = 2; // 这里通过{} 打开了一段局部作用域，这里的b只在当前的代码段里占用b的变量名
      a // 这里我们没有加分号，表示这是一个表达式，表达式会把值返回给调用者。
  }; // 因此这里内部的a表达式值会返回并且赋值给b变量
  b // 这里也是一个表达式 ，作为函数的返回值。
}

在rust中末行以表达式方式返回结果，当我们需要提前结束某段操作的时候，才会用到return返回。这点是不是和ruby coding style有点像呢？

2.安全

1
2
3
4
5
6
7
8

let a = 'a' // rust具备类型推导功能，这里'a'字面值是String类型，因而let a没有声明类型也可以完成定义a的操作。
let a = 1   // 这条语句也是let a = x，区别是它会覆盖之前的语句let a = 'a' 这样以前的a就不复存在，let a = 1会作为新生儿存在。
// 以下的这段代码会在编译时报错
let i = if true { // 由于没有显示的表面i量的类型 但是这里赋值操作是由if else流程控制，if true会是String类型,else会给一个integer类型，导致i推导不出类型，rust机智的把它透过编译器，捕获这个明显的不安全赋值操作。
  "1"
} else {
  1
}

ownership？move？borrowing?
首先让我们了解一下一个主流系统级编程语言具备的内存管理方案。

1
2

int a = 1; // stack区
int *p1 = malloc(4*sizeof(int)); // heap区

例如c语言中，存放在当前线程中的静态区域资源，会被统一放入一个叫做stack(栈)的内存区域中，然而每一个stack的空间是预先分配好的。并且是固定的，因而它会存入固定好的数据，例如常见的内建类型，int char，数组，字符串，字符等等。当我们需要在运行时动态的存放一些数据的时候，我们需要调用系统api，向操作系统申请一块来自heap(堆)区域的内存，这块的内存往往是程序运行时，我们向操作系统申请的，它能给多少就给多少，总的来说heap区的资源往往比stack区的容量更大。并且它对于stack来说是一个全局的概念，也就是说它可以跨越线程，而不是局限于线程内部。然而heap是靠地址申请来的内存，当你做内存操作的时候，你得去遍历到你对应的内存区域，然后做引用和修改，步骤比较繁琐，执行速度会略慢于stack，stack则是保持一种先进后出的执行顺序，它不停的将新来的内存向上推，当收到出栈指令的时候，它会快速的把最上层的挤出栈，从而在速度上超越了heap，或许这就是大佬吧。
回到当下，我们来看一看rust中的方案

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

// ownership
// rust里每一个值都有一个owner作为它的主人管理。  
let a: i32 = 1; // 这里1的字面值赋给了a a就是1的owner a的生命周期是由作用域决定的，当程序执行离开a所在的作用域时，会调用drop函数把a的内存给释放。这个特性被称之为RAII

let b: i32 = a; // 把a赋值给b会产生一个copy操作，因为a、b的值都是字面值，rust会视为这是一个"move"操作，讲a的值copy move到b里。

let s_a: String = String::from("heap string"); // 这里通过String::from动态的创建了一个heap区的值，赋给s_a
let s_b: String = s_a; // 这里同样会被视为move操作，在rust中move操作对于heap区的值来说，是一次浅拷贝，并且会把这里s_a标记为非法值，不能再次访问它，如果再次访问它否则会产生一个编译时报错。

// move
fn execute_convert(s: String) -> usize {
  s.len()
}
execute_convert(s_b); // 这行代码会产生move，s_b的值会被move到execute_convert的形参中，导致s_b被标记为非法值，再次访问就会报编译时错误。
// 想避免move，可以通过深拷贝，s_b.clone()的方式避免s_b被move成为一个非法值。

// rust中对于动态创建的对象还可以通过borrow的方式，防止s_b作为非法值存在。例如:
execute_convert_borrow(s_b); // 这里s_b会借给execute_convert_borrow函数执行，当函数执行结束后会安全的返回它的结果给s_b的作用域。
fn execute_convert_borrow(&s: String) -> usize {
  s.len()
}

// borrow的限制
let mut s0: String = String::from("heap_s0"); // 定义了一个可变的s0
let mut s1: String = &mut s_b; // 把s0借给s1 
let mut s2: String = &mut s_b; // 同一作用域又借给了s2 这时候会报一个编译时错误
// rust中不允许把同一个定义的值，同时借给两个不同的量，因为rust考虑到这样会出现data race(数据竞争)，两个mut的指针对于指向的相同内存区的数据可能会发生不同操作，导致出现脏数据的情况。
// 对于不可变的值不存在这种约束 因为是只读的
let s3: String = &s0;
let s4: String = &s0; // 不会报错 因为借给的是不可变的量


// rust编译器会避免悬垂引用 
// 例如：
fn main() {
  let reference_to_nothing = dangle();
}

fn dangle() -> &String {
  let s = String::from("hello"); //由于s是定义于dangle函数的作用域中，按照raii策略，rust会在dangle执行结束的时候，销毁s
  &s // 然而这里把s的引用作为返回值，会造成本该销毁的对象的地址被返回出来，让其他作用域的人继续持有它。这就是悬垂指针。
} // 这里会抛出编译时错误。

// slices
// 作为写javascript的熟手应该很熟悉数组的slice方法，rust通过类游标卡尺的方式可以针对String这种序列对象做c里的指针偏移操作，来实现取一部分数据。  
// 例如:  
let s = String::from("hello world");
let hello = &s[0..5];
let world = &s[6..11];

rust中怎么定义一个对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// 作为一个rails程序员用过factory_girl（现在叫做factory_bot）的人应该都难以忘怀ruby的dsl居然可以写出如此优雅的代码及注释。
// 在rust里，struct的设计就是类似这样的写法
struct User {
  username: String,
  email: String,
  sign_in_count: u64,
  active: bool,
}
fn build_user(email: String, username: String) -> User {
  User {
      email: email, // 这里也可以直接写email, 和javascript里一样省略重复名称
      username,
      active: true,
      sign_in_count: 1,
  }
}

let user1 = build_user(email: '2333', username: 'nickname');
let user2 = User {
  email: 'user2@rust.com',
  ..user1 // 通过..名称 可以实现剩余未显示定义的字段会集成与user1量中。
}

rust中的lifetime？

俗话说：”我叫你一声，你敢答应吗？”，rust里数据类型是通过绑定一个ownership，也就是说你取名的每一个数据类型它都是属于所有者自己的（例如let a = “1”, 那么a这个不可变的量是”1”的owner）。
虽然有：”凭本事借来的钱，凭什么要还？”，然而资源是有限制的，尤其是当我们进行系统级编程的时候，rust君认为，每一个owner可以通过借给别的owner自己的引用（也可以视为地址），来建立更方便快捷的操作，然而借走的资源，希望能按预期操作安全执行，是需要约定好双方的生命周期。rust君给每一个引用定制了生命周期，你需要用声明式的方式显示的定义好资源的声明周期，并且你需要告诉编译器大哥，你啥时候不再占有别人的生命周期，编译器大哥才能知道你这段内存操作是正确且安全的。
rust-lang文中有如下的一个例子：

{
    let r;                // ---------+-- 'a
                          //          |
    {                     //          |
        let x = 5;        // -+-- 'b  |
        r = &x;           //  |       |
    }                     // -+       |
                          //          |
    println!("r: {}", r); //          |
}                         // ---------+

以上代码编译后的样子^ borrowed value does not live long enough，哎？为什么没有变身魔法少女小圆？这是就是死肥宅的悲哀吗？no，这是因为编译器大哥，发现r君借走了x君的5块钱，这时候x君的生命已经结束了，意味着r君持有x君的钱应该也作废了，然而这里的r君对于x君的生死毫不知情，它只知道自己借走了5块钱，然而编译器大佬已经识破了一切，它告诉肥宅，x君已经祭天啦，请你告诉r君接走的x君的5块钱（引用）已经释放了，这时候在访问的话就会出问题的。
rust通过对每个引用对象，描述它的生命周期来确保了内存操作之间的安全。有一些流派提出了一种优雅的包含推导方案，来记忆rust中的lifetime的规律。
例如当你定义一个lifetime的时候，是描述这个引用的生存时间，需要注意它来自某个owner，以及这个owner的作用域在哪里，以后这个owner要怎么处置？是标记为非法还是继续使用？rust里认为lifetime的子类型的生命周期应该大于父亲类型的生命周期，这样可以确保，子类型不会误操作释放掉父类型的内存。

总结

嘛，先写这么多，等有空我继续补完。
待续…

为什么要把CSS当做一门技术学习

在我刚接触web开发的时候，认为页面大部分源码都直接获取，并且网上还有各大公司开发了很多图形化的桌面软件简化写样式的时间。这门完全没有逻辑符，纯语法块和属性的语言要有必要去学习吗？
后来工作了，忙碌的后端功能设计之后，因为对CSS的了解甚少，因而导致不能完成比较符合设计师或者说体验更好的前端应用。

重新认识页面

我们现代化的HTML页面可以简单的分为两个组成部分。UI和UX。
浏览器则把它UI分为CSS+HTML，把UX分为JavaScript。
HTML是一种描述页面的文档。CSS是一种浏览器实现的布局DSL，能够辅助HTML更优雅的描述文档一个页面布局的核心基本上是由CSS掌握。CSS通过修饰文档的行为，来实现一个页面的布局。

从认识文档开始

写文章和写文档对于大多数人来说，不是一件陌生的事情。
一篇有意义值得珍藏的文章，要有中心主题，每个段落和修辞它们之间会通过衔接上下文，来突出作者想要表达的中心主题。
我们可以把HTML当做干巴巴的文字，CSS则可以认为是纯修辞的写作手法，为了让浏览器更明确知道作者的中心思想，突出一个页面的主题。

CSS”修辞套路”

布局方案

在CSS中有这几种常用的写作手法会影响文档的布局： 1.文档流，2.浮动，3.绝对定位。
文档流：浏览器中的HTML默认的布局方式是按照我们自顶向下的方式来实现元素的布局。
浮动：浮动会，根据HTML中元素的文档流，再根据浮动的属性向浮动方向偏移，会影响周围的元素。
绝对定位：绝对定位是一种特殊的布局方式。可以把绝对定位理解为浮在普通文档流上的一种比较灵活的定位，它不会影响原来文档流的元素。

BFC(Block Formatting Contexts)

简单的理解BFC: 是一个独立的修辞手法，它可以被认为是一个可以装东西的箱子，箱子里物品的拜访是不受外界的影响的。
对于浏览器而言，BFC中的元素的布局是不收外界的影响（也就是说内部的元素是不会因为float, 或者绝对定位等影响文档流的布局受到牵连），这样而言我们可以更方便的定位布局在哪一个箱子里出了问题。不同BFC的元素不会出现外边距重叠现象，同一个BFC的相邻元素仍存在重叠现象。BFC的具体规则请参考

总结

在我们写CSS的时候，要去设计这个页面的文档（HTML）之后再去考虑如何用CSS去修饰它，设计CSS的时候应当去围绕盒子模型的概念，以及DRY的原则去设计我们的class和组件。当对布局方式和盒模型有一定概念的时候也会方便我们写出更有可读性和扩展性的代码，能高效高质量的还原UI & UE。

参考资料

http://www.topcss.org/visual-formatting-model/
http://kayosite.com/block-formatting-contexts-in-detail.html
https://developer.mozilla.org/en-US/docs/Web/CSS/Visual_formatting_model
http://blog.doyoe.com/2015/03/09/css/%E8%A7%86%E8%A7%89%E6%A0%BC%E5%BC%8F%E5%8C%96%E6%A8%A1%E5%9E%8B%E4%B8%AD%E7%9A%84%E5%90%84%E7%A7%8D%E6%A1%86/
http://layout.imweb.io/article/box-type.html

2017 12/31

这是一篇跨年的总结，在这个十分珍贵的2017质数年，我过得十分充实。这一年是我收获最多的一年。

故事的开始

2017年2月份，我抱着重新开始一段新工作生活的想法离开了第一财经新媒体，一家待遇很好并且有稳定投资背景的公司。因为之前就有去杭州的计划，加上自认为自己有一定竞争力，因此并没有想太多于是gap了一段时间，5月份去杭州尝试找工作，可能是机遇不巧、也许是竞争力不够，我只收到了两家公司的面试邀请，只有一家当天就说要给offer，于是我便选择了那家 杭州火球科技，月底入的职，大概在7月份的时候，因为我个人觉得在这里成长的很艰难，并且在沟通层面有困难，因此我提出了离职，总的来说在这家还是比较开心的，同事们都很年轻大部分都是95后段子手，在这家居然还碰到了前同事的基友，技术圈真的是很小啊。

换方向

17年我决定转行前端领域。
由于在用rails的过程中，很多黑箱操作被封装成了非常优雅易学的DSL，让你并不需要care太多细节。然而rails框架精髓并不是仅限于它的高效率开发和成熟的解决方案，它的核心精髓是基于ruby语言和许多常见的企业级解决方案的整合。由于我在第一财经曾经有过一段用koa的项目经验，在这个踩坑的过程中，让我对middleware有了更深层次的认知，以及在和一财前端大牛的交流之后，了解到了前端领域有很多从未了解过的设计模式，让我对前端有了新的认知。紧接着rails 5.1.x 发布了支持前端框架的脚手架，加上2017jsconf上的沙龙演讲，让原本打算从ruby转向nodejs后端的我，有了新的想法，我要做一个”前端”，而不只是一个api开发者。
为什么选择前端？前端随着backbone angular ember的出现，以及浏览器大战最后还在存留的公司，前端早已变化”多端”，ES规范的推行和实现，前端技术不再是以前那种对于css html js一窍不通的人都可以轻松学会的技术，多平台的浏览器，跨多设备的交互设计，能够快速满足产品原型，对于前端工程师来说，都是挑战。
我并不认为只学一个后端，就能做到后端领域的精通和深度理解，我认为学习前端和后端对于一个非科班出生的野路子程序员来说是一种便捷式的成长途径之一。因而我选择了前端，虽然这个大家公认的技术变化快，水深的领域。但是有很多应用的设计模式，其实源于古老的计算机科学知识，由于之前没法接触到，只有通过学习前端技术和去实战才能一点一点的去掌握它，弥补一个野路子程序员缺乏的科班知识。优秀的程序员必须要具备扎实的计算机科学知识。所以我转行做了前端。

变化

17年开始，许多互联网巨头公司在南京成立了运营和销售部门，部分成立了技术分部。711和罗森超市的入职，以及阿里在南京的一轮投资，南京即将成为互联网大城市阵地之一，对于我一个南京土著来说，也许将来我的梦想实现不聊了，那就可以回南京工作，节约一大笔吃住行的费用。

无法改变的，学会去享受。

不知道为啥，今年开始脚臭味特别重，出去玩的时候被机场的安检员鄙视，虽然对方说的是日语，可我也知道他第一句话认定我是泰国人，可能是因为脚上的味道很重，以及去面试的时候被面试官嫌弃，面试官当面放屁在用不欢迎的目光和不屑交流的语气打发我走人，坐高铁，整节车厢都能闻到我的脚臭味，边上接电话的乘客直接用方言在抱怨，我看了他一眼，结果愣住了，很尴尬。骑车从公司回家的路上，人行道上的人都可以闻到，都说第一次遇到脚味道那么重的人，参加公司的新员工培训大会，被参与的同僚直接吐槽这个人脚怎么这么臭…………
那段时间我很抑郁，每天洗2遍脚，甚至中午我都会去把换洗的袜子和免水洗手液带到公司里，偷偷换掉。但是没有任何用，去看了医生都说是脚气，可是脚上没有任何水泡和糜烂的痕迹，最后我开始在谷歌搜各种资料，才知道这叫做局部多汗症+臭汗症，容易出汗，并且出汗就会有脚臭味，是一个没法痊愈的遗传症状，而不是病。有很多做手术的方案，但是资料里说不一定保证能做好，而且需要切断一些重要的神经组织。我也看过网上的一些人说这是鞋子里有病菌，于是我买了几双非常贵的鞋子，以前从来没想过自己买的几双鞋子也会破费三四千的RMB，但是仍没有任何效果。不敢出门，不敢去公众场合，不敢和别人聊太多，更不敢靠近别人。直到有一天，我被动漫《灵能百分百》里的一句话打动 – 嫌な時はなあ、逃げたっていいんだよ！ 中文翻译大概是 不愿意的时候，逃避也没关系！，主角龙套是一个因为自己超能力伤人，而害怕和别人交际，并且不敢接受自己的除灵师，在TV版的最终战中他的师父一个普通人，为了让徒弟龙套放下罪恶感和自卑感，而说的。让龙套想起师傅曾经说过，”这不过是种特征，只要能接受这一个性，积极地活着，魅力的本质是人情味，变成一个好人，就这样！”。这让我想起曾经在哪里看到的一句话，”无法改变的，学会去享受。”
我没法改变自己的基因结构、身体构造，相貌身高。我也没法改变自己的命运，解决所有的难题，我也更没法保证自己的承诺就一定能履行。我也没法让所有人都成为我的朋友。只有积极地活着，魅力的本质是人情味，做一个好人。

魅力的本质。

14年年底的时候，我在cnodejs社区了解到了闪总（曹力）暴走漫画CTO、糗事百科core member，我被他的技术演讲和博客吸引，于是在微博上抱着试一试的态度投了简历，15年我去了上海和他面基，当时的面试情况并不好，但他并没有拒绝我，反倒是给了我和他一起工作的机会，在暴漫工作非常开心，至今我都会有空和暴漫的同事面基，线下聚会。至今为止，我心中最敬佩的CTO仍然是闪总，他和我身边接触的资深程序员orCTO完全不一样，一直在不停学习和接受新的知识，并且有自己的想法，有很强的技术管理能力，还是个低调的段子手。
我本身是一个自小就性格内向的人，以及不爱说话，这些因素导致我在语言交流时会有很多障碍，经常吐字都会慌乱，没法用语言舒畅的表达自己的想法。以前上学的时候我怕说话，基本上就没啥朋友。暴漫带给了我很多帮助，交到了朋友，去深圳做了一次”网红：银河系二皇子”，这些经历让我在交际上也有逐渐的改善，渐渐地敢于发表一些自己的想法。这些我都不是有目的的去执行，全都是魅力的本质，所吸引，去做去实现。
16年加入第一财经，万万没想到是，一个网友居然和我是同事，他的经历也十分值得我敬佩，高中获得NOIP省级一等奖（当时是我帮他内推一家知名大公司，他把简历发给我，我才知道），大学是读的清华大学医学专业，他并没有为了钱去选择做一个医生，直接步入财富自由的上流社会，也没有因为学校是清华和获得NOIP的奖项，选择那种高收入的金融科技公司，反而是拿着不高的工资在创业公司锻炼自己的技术，在17年的时候他拒了很多知名大公司给的高薪offer，以一年多的工作经验去了蚂蚁金服拿着普通人3~5年才能给的薪资。
我不一定能成为他们，我需要有和他们一样的魅力去影响我身边的朋友，做一个积极地人。

想法。

17年南京有个叫做钱宝的公司，CEO在近12月月末的时候去公安局自首，交代了自己的”庞氏骗局”，钱宝是一家做P2P金融的公司，它让用户的钱存放在它的系统里，然后给予用户高于市场上其他理财产品利润。其实正常公司不去做非法手段，根本没办法给用户利息的同时并且保证不亏本。这家公司在南京运营了6年，它的用户人群大多数都是一群抱着能做”中国梦”枕头的人。
我不认为持有的资金多少，就表示这一个人的安全感和生存、发展能力就高。我也不认为年轻时候多辛苦一点，多赚点钱，老了之后就可以懒在家里，靠着儿女或者国家养活自己，确实大多数行业不招收年过40、50的人，难道赚钱，只能是找工作？给别人打工？世界在随着时间变化，适者生存，只有去不断拥抱新变化，以及不断的学习，才能得到更多的安全感。反倒是”中国梦”，并不是给好吃懒做的人，而是给那些在奋斗的人。
社交网络开始有了限制，然而不会搭梯子的工程师，将拿不到最新的学习资料。自然也会淘汰一批程序员。不会docker的运维将再也没时间陪家里人，或者说找女朋友，更别说有竞争力。
和老同学见面吃饭，他说羡慕我是个做技术的，找工作有竞争力，起码不会找不到饿死。其实码农是个需要不断去学习和接受新东西的职业，职业地位和薪资福利。程序员职业在外人看来薪水高，然而外人看不到的是他们社交圈窄，社会地位低，没存在感。甚至是很多异性朋友不会选择程序员作为择偶标准。对于话少，性格内向，木讷的工科男来说，如何做到有收入的同时还能发展自己的人脉，是一件挑战，再加上性格内向和社交圈窄，生活中很多需要别人帮忙的地方，完全找不到入口。只要是有人放弃去学习和接受新东西，自然会因为世界的变化，最后也做不到适者生存，努力了不一定有回报，只要保持一颗积极地心态，一定会有收获。
曾经有个当网红的机会，我却没有把握，我不后悔，因为我并不喜欢当演员，甚至在玩狼人杀的时候，我的发言和思维都不能入戏。我不认为我当网红就能承担所有舆论责任，以及没有做一个焦点人物的必要，反倒是会让自己的朋友圈和微博进入演员状态，”江歌事件、杭州保姆纵火案、红黄蓝幼儿园虐童案”。有多少做新媒体的人士，不是为了抱着KPI的思维去写文章？有多少网红不是为了实现自己伟大的”财富自由”梦去扭曲真相。当事人、和作为一个局外人，我们最想知道的是真相，而不是资本家为了面子，砸钱去让有影响力的大V扭曲事实，让一群不明真相的吃瓜群众有了错误的认知。

成就。

• 用憋足的英语和憋足的日语和两个死宅基友、成功完成自由行日本
• 转行前端
• vue 独立做了公司的数据平台的产品
• github 成就
  https://github.com/Matrixbirds/poke
  https://github.com/Matrixbirds/eager-loader
  https://github.com/Matrixbirds/koa2-router-schema
• 去阿里参观&参加D2
• 去杭州玩

总结

我很感激2017年能有这么充实的经历，以及结交了新的朋友，完成了一些小梦想，2018将是我新的旅程。

阿里面试总结

简历过了

“您好，请问是xx吗？我是天猫前端部的xxx。我收到了您的简历。balabala”。（简历终于通过了筛选！开心！！）……

在杭州找工作的日子里结实了一位年轻的猎头基友，当时在家里投简历都快绝望了，投了N多家没有一家回应我的。和许多朋友交流之后，大家都吐槽我的简历烂。在他的点播下我学会了写简历（吹工作经历）。还帮我投了之后我入职杭州的第一家公司，最后能接到那家公司的面试邀请，也是因为猎头职业在圈子内的影响力吧。

面试

因为时隔久远，细节我记得不是特别清楚了，大致的内容还依稀残留于脑内。满满的伤。。XD
简单的让我自我介绍了一下。聊了聊做的项目和遇到的坑。破冰问题问了项目中媒体文件处理的大小和时间（因为时间隔的比较久，我完全忘记了…）。由于简历没有写前端的经验。所以大部分都在问后端的内容。还问了nodejs底层架构，讲真我nodejs实际使用时间只有2个月。（算现在的话 也只有4个月）

总结

天猫的面试让我看到了自己很多的不足。nodejs底层细节不了解，前端不熟，岗位是前端开发。面试过程很愉快。我总共经过了两轮面试，每一轮的面试官人都特别nice。因为那段时间我是在职期间，还特地问我说话是否方便，以及为什么离职。虽然我在离职理由层面表达的都不是特别好，但是面试官还是很理解，并表示很愿意理解我的情况。
天猫这个部门似乎是新成立的，做一些创新类产品研发。有强大的java后端支撑，同时有专门研究ar技术的组，面试还问了C10k类的问题，这里的前端应该也需要参与双11的秒杀系统的设计。
非常感谢我的朋友帮我内推天猫以及能和天猫的大牛们面试切磋。平定了我浮躁、傲慢的内心，路还有很长要走，我对js生态的认知以及了解深度，还仅是停留在打开新世界的大门阶段。

留给自己

好好学js，了解它的过去，认识它的现在。弥补我欠缺的计算机科学知识，多和大牛切磋，而不是混在自己的小圈子。

翻译的动机

任职服务端开发也有2年之久，个人是个野路子程序员，使用的都是Lowbee脚本语言。并没有过真·计算机领域知识学习。
++严重欠缺计算机科学背景，但是由于本人工作和生活中长期使用Linux，并且希望向女装程序员水平上靠拢，加上对于并发一直是懵懵懂。为了日♂后可以欢乐的play。因此尝试通过翻译这篇paper来作为一个知识点的学习。毕竟计算机是实战科学，因为工作目前不会接触高访问量的需求，所以后续有时间我会补上代码加以巩固知识点。
本文中部分章节可能会有缺漏，本人英译有限，有什么错误或者缺漏可以私我yooobuntu@163.com（反正也不会有人看。。）

正题

动机

如图[1]所示，一个基于BSD UNIX的软件架构的网络子系统。BSD UNIX 内核会调度异步通信设备（如：网络适配器和终端）和正跑在系统的程序，当网络数据包到达通信设备后，会由硬件发起一个电信号（也就是我们俗称的interrupt[中断])异步的发送给中断处理程序（也就是说发送这个电信号的操作，并不会立即执行并返回响应给发信号的硬件大爷），然后数据包会被中断控制器发送给操作系统内核（我们可以把操作系统前后端分离，前端视为用户态，后端视为内核，用户态只具有用户权限和申请获取资源能力，内核具备最高权限和资源分配能力）。这些中断处理程序会接受来自设备的数据包，并且会处理成高层协议（如：IP，TCP，UDP）。合法的数据包包含的应用程序数据会存在Socket层的队列中。内核酱会分发给等待消费数据的用户进程。这些受到数据包的骚年，会调用read内核api，用同步的方式读数据包里的内容。用户进程任何时候都可以调用read，当数据抵达时，当前进程会睡眠，直到数据成功抵达时。
在BSD架构中，内核异步地执行I/O响应给设备中断。相反的是，在用户态程序中同步地执行I/O。这种分离的关注点被称为”半同步、半异步”并发IO结构用于处理下面的两个问题：
1.简化编程：
使用异步I/O模型编程会比较复杂，因为输入和输出操作是中断触发的。异步会引发导致时钟问题和竞争问题，当前的线程可能控制权可能会被中断程序抢占，此外，中断驱动的程序运行栈会依赖额外的数据结构。这些数据结构用于显示地保存和恢复状态，这些状态是由事件异步地产生。再就是，调试异步程序比较困难，由于在程序运行时，在代码不同地点，产生了来自外部的事件。
相反，基于同步IO编写的程序相对于简单，因为I/O操作会在定义处产生，代码会按序处理。此外，程序会被同步I/O阻塞，等待I/O操作完成。使用阻塞I/O允许程序维护状态信息、调用历史，在运行时的栈活动记录里，而不是需要额外的数据结构管理。因此强烈建议使用同步I/O模型简化编程模型。
2.高效率地运行：
异步I/O模型有效地映射到硬件设备上，通过发送中断驱动。异步I/O可以同时处理通信和计算。另外，上下文切换开销小，因为维护程序所需的信息的状态数量相对比较小。因此，这里也是强烈建议使用异步I/O模型提高运行性能。
相反。完全地使用同步I/O可能是低效的，当每一个事件源（如：网络适配器，终端，计时器）相关的单独的活动对象（如：进程，线程），每一个这些对象都包含了一些资源（如：栈，一组寄存器）会发生阻塞，这时候就需要等待产生阻塞的事件源响应完成。因此，同步I/O模型会减少时间，用于创建必要的空间，调度，分发，结束一个活动对象。

解决方案

为了解决简化编程模型和提高运行效率之间产生的担忧，我们使用Half Sync/Half Async模式。这个模式以有效且良好的方式集成同步I/O和异步I/O模型。在Half Sync/Half Async模式中，
高级任务（如：数据库查询和文件传输）使用同步I/O模型，可以达到简化编程模型。相反，低级任务（如：处理网络控制器的中断）使用异步I/O模型，从而强化执行效率。因为在系统中的高级任务比低级任务更多，这个模式将异步处理的复杂性放置软件架构中的单独一层内。同步通信任务和异步通信任务会被编号并且有序的放入队列层。

适用性

使用Half Sync/Half Async模式

• 系统处理过程有这些特点：

  • 这个系统必须执行任务响应异步产生的外部事件。
  • 对于事件源使用独立的线程处理同步I/O是低效率的。
  • 系统中的高级任务在同步I/O模型下，编程模型非常的简单。

• 一个或多个任务必须在单个线程控制下执行，而其他任务可能会从多线程里得到收益。

  • 例如，历史库X-windows、SUN RPC 通常不可重入执行（non-reentrant）。因此多线程控制不能在并发情况下安全的调用这些库函数。但是，为了确保服务质量以及享受多CPU的好处，把大量数据传输和数据库查询操作放入独立的线程中执行可能是必要的。Half Sync/Half Async模式会抽离多线程程序中的单个线程，这个解耦可以满足不可重复执行函数的需求，不需要写额外的维护代码，以至于它们可以正确的执行。

结构和参与者

如图[2]所示是Half Sync/Half Async模式的设计参与者设计结构。参与者分为以下几种

• 同步任务层（用户态线程）
  • 这层执行高级I/O会是用同步的方式传输数据，这些任务会放入队列层的消息队列中。不像异步层，同步层的任务是活动对象，有自己的允许栈和寄存器。因此当执行同步I/O时他们会阻塞。
• 队列层（Socket层）
  • 这层为同步任务层和异步任务层，提供了同步和缓冲区。I/O事件被缓冲在队列层的消息队列中的异步任务处理，以便后续用同步任务检索。
• 异步任务层（BSD UNIX内核）
  • 这层为处理来自外部事件源（如：网络接口、终端）的低级任务。不像同步层，异步层的任务是被动对象，所以他们没有自己的运行栈和寄存器。因此他们不会无止境地阻塞在任何单个事件源上。
• 外部事件源（网络接口）
  • 外部设备（如：网络接口、磁盘控制器）生成事件的会被异步任务层接收并处理。

合作

如图[3]所示，Half Sync/Half Async模式下的参与者之间的活动合作过程：当有输入事件抵达外部事件源（输出事件也是一样的方式处理）。这些合作过程被分成三个阶段：

• 异步阶段 - 该阶段，外部事件源会与异步任务层通过发送中断和异步事件通知通信。
• 队列阶段 - 该阶段，队列层提供明确的同步点，这样缓冲区消息会把在同步和异步任务层之间传递以响应给输入事件。
• 同步阶段 - 该阶段的任务在同步层会检索放在队列层中的异步任务。注意协议决定数据以什么方式被传递，队列层负责调解相交的同步和异步任务层相交的通信。
  异步和同步任务层如图[3]，通过”生产者与消费者”模式通过消息通信。理解这个模式的关键点是理解同步任务是活动模型。因此他们调用读写会引起阻塞，在任何时候都取决于他们的协议。如果数据还不可用，这个活动任务会进入睡眠，直到数据达到。反之，异步层的任务是被动对象，被动对象会触发来自外部事件源的通知或者中断。

总结

Half Sync/Half Async模式有以下几种好处：

• 高级任务编程模型简单，因为他们屏蔽了低级异步I/O。复杂并发模型，信号中断处理，计时器分发委托给异步任务层。异步任务层负责处理低级任务的细节，异步I/O编程模型（信号中断处理）。异步层同时也调度具体的硬件组件（如：DMA，内存管理和设备寄存器）。
• 同步方案在每一层都低耦合。因此每层不需要使用相同的并发控制策略。例如，在单线程的BSD UNIX内核，异步任务层通过低级任务机制（如，升降CPU的中断级别）实现并发控制，相反处于同步任务层的用户态，通过高级同步构造（如：信号量，消息队列，竞争资源，锁记录）实现并发控制。
• 内部层通信通过同一个端，因为所有的交互都由队列层调度。队列层缓冲的消息会被发送到同步和异步任务两层。这样就消除了锁定和序列化的复杂度，不管是同步还是异步任务层，都可以直接的访问他们自己的内存。
• 多处理器改善性能。使用同步I/O模型可以简化编程模型，并且在多处理器上会有性能提升。例如：持续时间长的数据传输（如：从数据库下载较大的医疗方面的图片）可以通过同步I/O模型，简便并高效的处理。一个处理器可以分配给传输数据的线程，促使相关联的CPU让整个传输操作享有CPU的指令和高速缓存。
  Half Sync/Half Async 模式有以下几个缺点：
• 同步数据拷贝和上下文切换的开销可能会存在引起交叉的边界惩罚。这个开销通常产生于当同步、异步任务的队列层传输数据时。特别是，大多数操作系统适用Half Sync/Half Async模式，在用户态和内核态领域边界安置队列层。当发生边界交叉时，会有明显性能上的惩罚。例如：基于BSD UNIX的Socket层，占有大量比例基于TCP/IP的网络开销。
• 缺乏面向高级任务的异步I/O。由于异步I/O依赖系统接口的设计，因此可能高级任务不能利用提供了低级异步I/O设备。因此系统I/O结构可能会避免应用程序高效的利用硬件，尽管外部设备支持异步重叠计算和通信。

实现

1. 定义耗时长的任务并且使用同步I/O实现

许多系统的任务可以很容易的使用同步I/O实现。通常，耗时任务传输大的数据流或者执行数据库操作时可能会阻塞并长时间等待服务器响应。
实现这些耗时任务可以采用活动对象模型。因为活动对象有属于他们自己的运行栈和寄存器，当执行同步I/O时，他们会阻塞。实现活动对象机制，依赖一个切换上下文控制的方法。在底层，这意味着有空间存储当前线程状态的硬件（例如，所有值，包括线程的栈指针，都会存在线程对应的寄存器中）并且加载一个新线程的状态。这样足以实现一个不需要保护内存的非抢占式线程机制。”用户态线程”包通常提供了这样的功能。
但是，需要依赖更多多任务操作系统的特性，将活跃对象模型健壮的线程化和进程化。在这个案例中，每一个线程控制都有属于自己的地址空间，这些地址空间会被处理器的内存管理单元（MMU）管理。当切换之间的线程时，新的进程地址空间信息必须加载到MMU中。也可能还需要缓存刷新，特别是某种类型的虚拟地址缓存。除了地址空间，操作系统的进程通常有”用户标识”，这样操作系统才知道这个进程的访问权限以及有多少资源可以使用。
为了避免单个进程无止尽的霸占系统，因此变有了抢占的方式。抢占通常由计时器完成。计时器会定期地（例如：0.01秒）生成一个时钟中断信号。在这个中断期间操作系统会查看当前执行的进程是否需要被抢占。如果需要，它会保存这个进程的状态并且加载下一个进程的状态执行。当中断信号返回，那么新进程将开始运行。

2. 定义耗时短的任务并且使用异步I/O实现

系统中的某个任务不能长期阻塞住。通常这些任务会使用耗时短且通过与外部事件源交互实现（例如图形界面、中断信号驱动的硬件网络接口）。提高性能并且确保响应时间，这些事件源必须无阻赛的提供服务。
实现这些耗时短的任务使用响应式，被动对象模型。被动对象会借助来自任何地方的线程控制（例如：调用者、独立的中断栈）。因此，这些任务必须使用异步I/O因为它们不会长时间阻塞。主要的动机是不会阻塞，确保充足的时机响应别的任务。（例如：优先级高的硬件中断，时钟计时器）。
这里有几种方式开发一个结构不错的异步I/O框架：

• 使用Reactor模式多路分解事件 - Reactor模式调度单个事件循环线程 - 该线程支持多路分解和分发多个任务管理者，支持并发地触发多个事件。这个模式将简单的一个单线程事件循环模型和基于面向对象编程扩展模式相互组合。Reactor模式序列化事件处理在一个进程或者一个线程里并且它通常不需要更复杂的线程、同步或者加锁。
  Reactor可以通过中断执行同步和异步事件源实现。Reactor会提供一个异步的事件处理，因此这个事件处理不会阻塞不会妨碍到响应其他事件源。
• 实现多级别中断方案 - 这些实现允许非时间关键被高优先级任务处理（例如：硬件终端），当有高优先级事件时必须提前执行。异步层的数据结构必须被保护（例如：通过提高处理的优先级或者使用信号量）避免中断处理器同时被访问从而破坏共享状态。
  例如，在操作系统内核中，对多级中断方案的需求受到硬件中断服务时间的强烈影响。如果这个时间可以显着降低，则在硬件中断级别执行所有处理可能会更有效，以避免额外的软件中断的开销。 TCP / IP的实现降低了入站分组协议处理开销，使得两级中断方案的成本支配整个分组处理时间。

3. 实现队列层

队列层提供了同步点用于缓冲交换同步任务层和异步任务层之间的消息。以下的几个论点会围绕设计队列层的寻址：

• 并发控制 - 当一个异步任务层和同步任务层并发执行时（既可能是多个CPU决定也可能是中断决定）有必要确保并发访问共享队列的状态是会避免资源竞争的。因此队列层通常会使用并发控制机制实现，例如信号量，互斥，竞争资源。这些机制会确保信息可以被队列层插入和删除并且不被内部数据破坏队列内数据的结构。
• 层和层之间的控制流 - 系统不能无限制的将很多资源奉献给队列层的消息缓冲区。因为同步任务层和异步任务层的数据传输是有必要调节的。例如：层和层之间的控制流程应当避免同步任务因为消息过多淹没异步层，影响网络接口的传输。
  同步层任务会阻塞，因此当同步任务正在处理等待更多的数据时，正常的流程控制方案是会让它进入睡眠。当异步任务层在离开队列时，下面的某个级别的同步任务会被继续唤醒。反之，异步任务不会阻塞，因此，如果它们产生过多的数据，则公共流控制策略将使排队层丢弃消息, 因此，如果它们产
  生的数据的量过多共用流控制策略是有排队层丢弃消息。当消息有关联的依赖面向可靠连接的网络协议时，它的发起者最终会超时，并且重发。
• 数据拷贝开销 - 一些系统（例如：BSD UNIX）会在用户态和内核态之间存放一个队列层。通常的解耦方式是通过拷贝它们之前的消息。然而，这样会增加系统总线和内存的读取，当有大消息的传递时，会明显地降低性能。
  一种方式是减少数据拷贝的，分配一块内存用于共享在同步和异步任务层。这样允许两个层之间数据直接交换，不需要通过拷贝到队列层。例如，提供一个I/O子系统，通过轮训中断信号来改善处理连续的媒体I/O流。这种方法还提供了一个缓冲管理系统，允许高效的分页重新映射同时共享内存机制可以跨用户态，内核，以及设备。

参考资料

PLoP-95.pdf

alias和alias_method

alias是什么？它是一个方法么？当然不是啦，它是一个逼格很高的keyword并且它永远指向当前作用域的self。keyword是语言的一部分不可被ruby程序覆盖。例如有下面这段代码：

1
2
3
4
5
6
7

def alias(&scope)
  scope.call('1024')
end

alias :io, :puts
io "hola"
# 输出 hola，可见这里alias并没有被覆盖

永远指向当前作用区的self

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class A
  def hola
    "hola"
  end

  def self.add_hello
    alias :hello :hola
  end
  add_hello
end

class B < A
  def hola
    "你好"
  end
  add_hello
end

puts A.new.hello # 输出 "hola"
puts B.new.hello # 输出 "hola"
# 可见 add_hello 方法里的alias并没有因为调用的scope变了导致hello方法变了

alias是引用还是创建？（以下是我的机器上输出的结果）：

1
2
3
4

a = A.new
a.method(:hola).object_id # 输出 70144731241200
a.method(:hello).object_id # 输出 70144731223640
# object_id并不一样 由此可以推断是创建了一个的对象

聊聊alias_method。它是一个ruby标准库的方法（它默认写在Kernel的私有实例方法下面）。不是词法的一部分，是标准库的一部分。它很灵活，而且是一个on call的self绑定。它可以被重写（当然一般我们不这么乱用膜法）：
什么是on call?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class A
  def hola
    "hola"
  end

  def self.add_hello
    alias_method :hello, :hola # 由于是方法因此这里是要给参数的，当参数和形参不匹配的时候会报错的
    add_hello
  end
end

class B < A
  def hola
    "你好"
  end
  add_hello
end

puts A.new.hello # 输出 "hola"
puts B.new.hello # 输出 "你好"
# 这就是on call 因为B类里重写了hola方法 所以B类里的alias_method会根据B的方法生成hello方法

bcrypt-ruby

这是一个简而美的gem，用于实现加密功能：（如用户密码）。因为简单易用的特性，被rails官方团队加入了Gemfile里。

简而美

1
2
3
4
5
6
7
8
9
10
11
12

# Gemfile

# Use ActiveModel has_secure_password
gem 'bcrypt', '~> 3.1.7'
## 这是一段在rails里简单的使用demo
# app/models/user.rb
class User < ApplicationRecord
  has_secure_password # 默认需要有一个password_digest字段来存密码
end

User.find(1).password_digest 
# $2a$10$N9qo8uLOickgx2ZMRZoMyeIjZAgcfl7p92ldGxad68LJZdL17lhWy

WTF就这样？

你可能会吐槽，握草！居然不需要使用者指定salt，莫非是公用同一个salt？这种加密跑个简单的rainbow table不就好了？
握草太可怕了，我再也不敢用gem了，我要去造轮子。骚等，先喝杯咖啡静静。
再回到之前的一段密文字符串里：

1

"$2a$10$N9qo8uLOickgx2ZMRZoMyeIjZAgcfl7p92ldGxad68LJZdL17lhWy"

根据wikipedia里的描述，bcrypt加密后是由于$2a，$10，$N9qo8uLOickgx2ZMRZoMyeIjZAgcfl7p92ldGxad68LJZdL17lhWy这3段字符串构成的密文密码。
$2a表示所用的bcrypt算法的的版本，$10表示需要计算的次数。下面一段字符串逼格比较高，也是本例密文里的核心部分。这段密文其实是一段混合密文密码+salt的字符串。
需要换个姿♂势解读我们把$忽略，留下N9qo8uLOickgx2ZMRZoMye，IjZAgcfl7p92ldGxad68LJZdL17lhWy。前者是一段密文，而后者是一段salt。
WTF？日了狗了？这段salt哪里来的？！莫非是有人黑了我的代码？！莫方。它的诞生其实是来源于我们的bcrypt-rubygem。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# lib/bcrypt/engine.rb
def self.generate_salt(cost = self.cost)
  cost = cost.to_i
  if cost > 0
    if cost < MIN_COST
      cost = MIN_COST
    end
    if RUBY_PLATFORM == "java"
      Java.bcrypt_jruby.BCrypt.gensalt(cost)
    else
      prefix = "$2a$05$CCCCCCCCCCCCCCCCCCCCC.E5YPO9kmyuRGyh0XouQYb4YMJKvyOeW"
      __bc_salt(prefix, cost, OpenSSL::Random.random_bytes(MAX_SALT_LENGTH))
    end
  else
    raise Errors::InvalidCost.new("cost must be numeric and > 0")
  end
end

是不是瞬间被这个gem所折服了？

参考资料

https://en.wikipedia.org/wiki/Bcrypt
http://stackoverflow.com/a/6833165
https://github.com/codahale/bcrypt-ruby

2016 11/28

最终还是没有忍住，比15年提前了一个月写了这篇年终总结。这一年发生了太多的事情。
因为个人原因我五月末离开了暴漫，加入了新公司（第一财经新媒体)。几个月后暴漫发生了大规模的裁员，上海、成都、南京等部门都几乎没了人。
感叹现实是多么的无情，因为裁员的原因，我开始和以前不怎么关注的同事小聚交流，我们一起吐槽在暴漫的日子，后来发现他们身上都有着不少闪光点（如果你看到了在暴漫工作的简历，请不要犹豫、约他/她来面谈）。
简单的review去年的总结，好像什么都没做，也好像都做了很多计划之外的东西，但是都不够完整，不能拿出来吹逼。

2016年我的收获

• kindle
• 鼠绘板
• 一些书
• 一些正版软件
• 一家全新的公司
• 尝试了用js做后端开发，学习了Elixir，生产我也用上了docker
• 一个独特的朋友
• 一些idea
• 一个新目标（运营一个公众号）

生活不只是眼前的苟且，还有诗和远方

我不知道这句话是否适合做标题，但它在我最需要的时候点醒了我。生活不能看着眼前，你还有更多需要去尝试的东西等着你去挖掘，有些是期待你去挖掘，有些则可能与你无缘。
但是不尝试，赖在原地怎么会知道生活的味道？
在加入新公司之后，经历了一些不愉快，分析下来80%是自己的问题20%是公司的环境，生活不只是眼前的苟且，还有诗和远方，我在交际方面存在许多问题，但是逃避好像并不能治本。
应该把在技术上的热情放在生活上，这才是我现在的钢需。在一些好朋友的帮助和鼓励下，我开始慢慢去学习跳出自己的圈子，开始尝试一些曾经不喜欢的事情（看非技术书，尝试运营公众号和
一些外向的人交流，去人多的商场，学习手绘）。发掘原来我的生活除了网络，还有更多的东西值得去花时间和精力去投入。这是一个难忘的成长阶段。

要成为什么样的人？

我要成为火影！，我是要成为海贼王的男人！。总是会被问到，将来想成为什么样子的人之类的话题。
这些话虽然显得很中二，但因为我并不是很了解自己，我也不敢乱给自己定无法实现的目标。不过正是因为有这样的问题，我才会反思自己。然而总结出来的自己却是模糊的。
按照某本书上的话来说，人在生活中总是会遇到吸引你的事物，如果它是人，你可能会去模仿他，如果它是物，你可能会想办法获取它。因为这样才可能发展出你的特点。
虽然不知道自己未来能成为什么样子的人，但是未来的性格和爱好，多半是由这些事物所影响的。人们都喜欢收藏这些事物，可能是人，也可能是物。可以把这些东西看作是一个圈子。

来上海有一年多了，我圈子小，接触的大多数都是搞技术的，有艺术型爆栈程序员，有创业大佬，还有天才型程序员以及野路子程序员。他们身上都有吸引我的点，颠覆了我曾经眼中的程序员模样。
于是我也开始模仿，曾经我觉得程序员大多数思想jiang化，比较木呐。直到有一天我发现他们真的不只是会coding，有的是因为从小的教育所导致，爱好广泛（手绘，旅游，写作，音乐），编程只是爱好之一。
有的是眼界广，不光着迷与技术，还热爱人文科学。从他们身上我总结出来，一个人的思维活跃度，取决于他对这个社会的关注点，然而关注点则取决于眼界。

对于目前的我来说，需要去跳出自己的圈子，去接触更多的人，尝试更多的陌生事物，才会有所成长。
以前我对技术看的特别的重要，我会花费大量的精力和时间去填补自己的缺漏，最后发现，努力决定下限，天赋决定上限。这句话还是蛮有道理的。
我好像没什么做技术的天赋，但是我会去努力提高自己的下限。我没什么显著的优点，我在努力方面还是愿意花费精力的，2017年希望把更多时间放在做有意思的事情，提高眼界。

2017的计划表

• 坚持用Linux编程
• 坚持刷题
• 用Elixir做个side project
• 多读书
• 学习手绘
• 学习写作
• 学习运营公众号
• 去舟山吃海鲜，去杭州品真宗的杭帮菜

致新的自己

做有趣的工程师。