写在前面

终于敲完了两本书的所有示例代码，整个过程还是蛮特别的。

看这两本书纯粹是因为之前读了《黑客与画家》，对作者屡次提及的Lisp感到好奇，想要了解下，然后在common lisp和scheme中毫不犹豫选择了后者，仅仅因为它看起来小而巧，而选择这两本scheme书，也是Google到的缘分，现在看来，觉得特别幸运，遇见了这样特别的书。

书中多处致敬了多位在数学和计算机领域作出贡献的人，还顺带调侃了下《动物庄园》里面的名句，令人捧腹。而往往在你看不懂代码，一头雾水，烦躁不安时，作者又时不时整一两句有关食物的调皮话，让人一下子又觉得没那么难懂了。

如果所有的编程书都能用这种方式去写，那该多有趣，可惜能把复杂的东西用这样特别的方式呈现出来，对于作者本人的要求着实不低。

这里简单屡屡两本书的大致内容以及遇到的问题。

《the little schemer》4th

全书10章，入门级，从最基本的概念说起，难度比较大的是chapter09，有关Y-combinator的推导，虽然我目前不是很清楚，Y-combinator到底有怎样特别的用途，但是整个的推导过程并不难，耐着性子跟着作者的思路走就好，而且等你完成这个推导过程后，你会发现读《the seasoned schemer》chapter 16时，Y-bang 已经不再让你感到困惑。

最后一章chapter 10算是初级版本的scheme解释器，好比手把手教你写一个用scheme解释scheme语法的工具。说它是初级版本，是因为在《the seasoned schemer》chapter 20 中，作者对这块的代码重构了，加入了letcc, set!等，算是终极版本。

这本书遇到的问题不多，主要是在chapter 6 。

chapter 6 shadow部分，章节最末尾针对(())，(() ())，(() () ()) 类列表定义了函数：+，lat?， 但这两个函数是无效的，执行时，无法输出结果，也许这正是章节标题 shadow的含义。

《the seasoned schemer》

全书10章，是《the little schemer》的进阶版。

个人觉得这本书相对有些难度的是chapter16和chapter19。

chapter 16中引入了Y-bang，并定义了一个函数biz用来告诉你它与 Y-combinator其实并不一样，但是具体为何不同，需要自行推导。嗯，你都能推导出Y-combinator了，这个自然也难不倒你，带着肥宅水上路吧！

chapter 19 中你会看到一个不一样的continuation，真的是很special的一个continuation。反正我自个儿是刷了两三遍才get到two-in-a-raw* 为什么可以那样定义，看完这章的时候，还想着整理点continuation的用法记录下来，结果看完wiki上有关call-with-current-continuation 举出的示例代码后，深深觉得自己水平太低，对yin-yang puzzle那块更是懵逼的一塌糊涂，先埋个坑吧，期待日后也能写一写阴阳谜题。

chapter 20 呼应着《the little schemer》chapter 10，完善了原先的代码，如果你一路走下来对每一章都理解的七七八八，这一章看下来会觉得没啥难度，看完不要忘记奖励自己甜点啊。

这本书遇到的问题主要在chapter13 和 chapter14。

chapter 13 hop skip jump 部分，书中直接使用的letcc，在mit-scheme中无法使用, 报错：Unbound variable: letcc，因为它没有定义这种缩写形式，建议练习时，遇到letcc的地方，都改用(call-with-current-continuation (lambda ....)). 或者你也可以这样

(define call/cc call-with-current-continuation)

使用 call/cc 来代替，这样也算是某种简化了。

chapter 14 let there be games 部分，章节末尾出现了try， 但是那段代码无法正常执行，没有Google到解决方法，书中给出的try解释也让人有点懵逼，至少我觉得 a 中应该出现 x。不过对该章节印象还蛮深刻的，作者不断的改进函数leftmost，算是结结实实体验了一把Refactoring scheme version。

chapter 20 中，在使用 let 去重定义*const 时出现了重复代码，可能作者急着去party而忘记删除了😂。这个不算问题，算找茬😄。

结语

自然是强烈推荐这两本书，第一次发现原来编程书可以写得这么有意思。

写在前面

翻墙小白一枚，按照网上的这篇用Google Cloud Platform搭建Shadowsocks服务教程 来搭建小飞机服务，但是操作的过程中踩了点坑，这里记录下在服务器上搭建的详细过程， 以备下次少踩点坑。

有关申请GCP和创建实例的步骤，这里略去，以下操作步骤基于Ubuntu 18.04.2，主要的命令语句参考用Google Cloud Platform搭建Shadowsocks服务教程。

准备工作

创建实例后，点击VM实例页面中的SSH按钮，连接到服务器。

登录服务器后，先获取 root 权限：

sudo -i

更新系统：

apt update
apt upgrade

启用BBR

BBR 由 Google 开发，供 Linux 内核的 TCP 协议栈使用，具体我也不甚了解，可以简单理解为它能加速网络传输速度。

好了，启用吧。

写入配置：

echo "net.core.default_qdisc=fq" >> /etc/sysctl.conf

echo "net.ipv4.tcp_congestion_control=bbr" >> /etc/sysctl.conf

配置生效：

sysctl -p

校验：

lsmod | grep bbr

看到输出类似tcp_bbr 20480 这样的内容，则表明启用成功了。

搭建SS Server

SS Server的安装可以参考官方文档：shadowsocks.

更新软件包：

apt-get update

安装python-pip：

apt-get install python-pip

使用 pip 安装 SS server：

pip install shadowsocks

安装成功后，创建配置文件：

vi /etc/shadowsocks.json

在文件中添加以下内容：

{
    "server":"0.0.0.0",
    "server_port":8388,
    "local_address": "127.0.0.1",
    "local_port":1080,
    "password":"password",
    "timeout":300,
    "method":"aes-256-cfb"
}

这里：server_port， password对应的是之后你在Shadowsocks客户端上配置的端口和密码，请自定义。

保存文件后，启动SS server：

ssserver -c /etc/shadowsocks.json -d start

看到输出started，则表示启动成功。

但是很不幸，我执行这一步时，启动报错，显示：

undefined symbol EVP_CIPHER_CTX_cleanup shadowsocks start failed

参考这篇ShadowSocks2.8.2启动报错”undefined symbol EVP_CIPHER_CTX_cleanup”， 作者指出是由于openssl升级导致，按照文章指示，做了如下操作：

编辑/usr/local/lib/python2.7/dist-packages/shadowsocks/crypto/openssl.py 文件：

【这里文件地址可能不大一样，你可以使用find找到shadowsocks/crypto/openssl.py文件】

使用 vi 打开文件，将文件中所有EVP_CIPHER_CTX_cleanup都修改为EVP_CIPHER_CTX_reset。

作者在文中很贴心的指出共有两处，在第52行和111行，感谢作者的分享。

修改完成后，重新启动SS server即可。

更多SS server相关命令，参考shadowsocks wiki.

设置开机自启

创建脚本文件：

vi /etc/init.d/shadowsocks

添加如下内容：

#!/bin/sh

start(){
　　　ssserver -c /etc/shadowsocks.json -d start
}
stop(){
　　　ssserver -c /etc/shadowsocks.json -d stop
}
case "$1" in
start)
　　　start
　　　;;
stop)
　　　stop
　　　;;
reload)
　　　stop
　　　start
　　　;;
*)
      echo "Usage: $0 {start|reload|stop}"
      exit 1
　　　;;
esac

为该文件添加可执行权限：

chmod +x /etc/init.d/shadowsocks

新建shadowsocks.conf:

vi /etc/init/shadowsocks.conf

添加如下内容：

start on (runlevel [2345])stop on (runlevel [016])pre-start script
/etc/init.d/shadowsocks start
end script

post-stop script
/etc/init.d/shadowsocks stop
end script

执行：

update-rc.d shadowsocks defaults

开机自启设置完成。

如果开机自启没有成功，请检查下/etc/init.d/shadowsocks 文件，确保脚本中不存在语法错误，比如中文符号。

防火墙配置

写这个是因为当时按照教程搭建完SS server后，发现还是翻不了墙，又不知道哪里出了问题，领导帮忙debug了下，修改了防火墙规则，问题解决。

在GCP 主页中，选择菜单 VPC 网络 =>防火墙规则， 创建防火墙规则:

查看日志

less /var/log/shadowsocks.log

如果日志上没有访问记录，可以考虑查看防火墙状态：

ufw status

或者查看端口情况：

netstat -anp

判断问题出在哪里。

参考：

用Google Cloud Platform搭建Shadowsocks服务教程

ShadowSocks2.8.2启动报错”undefined symbol EVP_CIPHER_CTX_cleanup”

看的是三联版，全书五十章回，第一次拜读金庸大师的作品，切切实实感受了下大师的博学。

大致的情节就不细说了。97黄日华版的《天龙八部》还是比较忠于原著的，演员演技在线，很经典的一版，少室山下的那场大战，三兄弟各带音箱，不论是剧还是书，都看的人大呼过瘾。

剧中与原著出入有些大的算是无崖子那段，在大理无量山下，跟他一起琴瑟相合，并诞下一女的是李秋水，而不是他的小师妹，电视剧算是帮无崖子圆了个梦。

书中虚竹的首次出场，也颇让人意外：

这僧人二十五六岁年纪，浓眉大眼，一个大大的鼻子扁平下塌，容貌颇为丑陋，僧袍上打了许多补钉，却甚是干净。

因为对樊少皇扮演的虚竹印象深刻，所以看到这段的时候，压根儿也想不到这个“容貌颇为丑陋”的僧人竟然是那个呆萌呆萌的虚竹啊！

书中人物众多，看到别人评金庸小说的，有提到段誉和王语嫣，认为段誉爱的不过是无量山下的那尊玉像，而非王姑娘本身，只是王姑娘恰恰同神仙姐姐模样一般，算是类的一个具体实例，又心许表哥慕容复，对他不甚在意，俗话说，得不到的蠢蠢欲动，更让他对王姑娘欲罢不能。

对段誉的痴情不做评论，毕竟书中论痴情，游坦之才是当之无愧。因为阿紫，面目全非，双腿残废，毫无怨言，甚至为了让心爱之人能重见光明，不惜在虚竹面前自刎以要求换目，他明明知道她对她姐夫情根深种，自己所做的一切也未曾得到阿紫半点正面的反馈，却依然无怨无悔，最大的心愿，竟不过是能成为相伴阿紫左右的一个奴仆。最后随着阿紫跳入雁门关外的深渊之中，也算是求仁得仁了吧。

有时候想，如果他换一种方式，努力研习《易筋经》，成为像萧峰那般的人物，也许这样反倒能让阿紫对他多份仰慕和心许。可惜，这一生渺渺，没有如果。

作为书中悲剧性的人物萧峰，不能不提塞上牛羊空许约。

萧大侠是幸运的，在被万人唾弃之时，遇到了痴痴不悔的阿朱。

以前看电视剧的时候，以为阿朱是为了救自己的爹爹段正淳才心甘情愿被萧峰一掌打死，看原著才知道，其实真正的原因，不仅仅是为了让萧峰放下心中的仇恨，更是她顾虑到如果萧峰杀了段正淳，大理皇室自然不会善罢甘休，而大理段家的六脉神剑可能会让萧峰有性命之忧。而她最后嘱咐萧峰照顾阿紫，又何尝不是担心他在自己死后自刎？为了自己的心上人，这般用心良苦。无怪后面耶律洪基要赏赐萧峰上千美女时，萧峰只是苦笑，心道：阿朱就是阿朱，四海列国，千秋万代，就只一个阿朱。

而对阿朱来说，又何尝不是萧大哥就是萧大哥，四海列国，千秋万代，就只一个萧大哥。

如果萧峰没有在雁门关外自刎，我倒是很希望他能随完颜阿骨打回到女真族的部落，远离厮杀的江湖，牧羊打猎，平平淡淡度过余生，也许这也是阿朱希望他去过的生活。

书中其他配角人物的描写也很精彩。比如灵气十足的钟灵，惊鸿一面的木婉清，四处留情的段王爷，幡然醒悟的鸠摩智，一生钟情无崖子的童姥，终极大boss扫地僧，收归于西夏一品堂的四大恶人……哈哈，说到四大恶人，很喜欢那个使鳄鱼剪的南海鳄神，挺可爱的，身上有种傻气的执拗，每次看到他出场了，就会觉得很好玩，刚开始被迫认段誉为师，实非本意，但是后面见识到他的凌波微步，内心已然接受了这段师徒关系，虽常常爆粗口骂人，老大不情愿的在人前称呼段誉师父，但是心肠并不坏，算不上真正的大恶人，最后还为了救段誉而被段延庆杀害了。

整本书里面，最不喜欢的就是包不同了，真的是恨不得分分钟让他闭嘴啊，处处抬杠也就算了，还非得借抬杠来显摆自己，真心hold不住这类人。

97版的《天龙八部》，片尾曲是周华健的那首《难念的经》，林夕作词，刷这本小说的时候，委实听了不少遍，词中掺着点佛理，林夕果然是写词高手。

怪大地众生太美丽。

附上这首歌：

写在前面

源于工作中一次组件的重构，这里重新写一个例子来练习下嵌套 slot 的使用。

嵌套 slot 需要使用到 v-slot 命令，使用该命令需要确保Vue 版本为 2.6.0 +。

完整的代码可见：TodoExamples.

示例

问题描述

现有一个 ToDoList 组件，其子组件 ToDoItem， 组件内容分别如下：

<!-- ToDoItem.vue -->

<template>
  <li>
    <span class="text-muted mr-1">{{ item.id }}.</span> {{ item.title }}
  </li>
</template>

<script>
export default {
  props: [ 'item' ]
}
</script>

<!-- ToDoList.vue -->

<template>
  <ul>
    <ToDoItem v-for="item in items" :key="item.id" :item="item" />
  </ul>
</template>

<script>
import ToDoItem from './ToDoItem'

export default {
  components: { ToDoItem },
  props: [ 'items' ]
}
</script>

在 schedule 中调用 ToDoList 组件：

<!-- schedule.vue -->

<template>
  <div class="container">
    <div class="row">
      <div class="col-md-6 offset-md-3">
        <ToDoList :items="items" />
      </div>
    </div>
  </div>
</template>

<script>
import ToDoList from '~/components/ToDoList'
import _ from 'lodash'

export default {
  components: { ToDoList },
  data() {
    return {
      items: [
        { id: 1, title: 'todo item 1' },
        { id: 2, title: 'todo item 2' },
        { id: 3, title: 'todo item 3' },
        { id: 4, title: 'todo item 4' }
      ],
      finished: [ 4, 2 ]
    }
  }
}
</script>

页面效果如下：

在 schedule 中，有一个数组 finished，里面存放了已经完成的 item 的 ID，现在需要在已经完成的 item 后打上☑️。

实现如下效果：

解决方法

要实现上述效果，有多个方法，这里采用嵌套 slot 的方式来解决。

主要思路：通过在 slot 上绑定属性， 让 schedule 层可以访问到 ToDoItem 中的 item，然后通过判断 item 是否在 finished 中出现，决定是否将☑️插入到组件 ToDoItem 中。

具体操作如下：

• 给ToDoItem 添加具名插槽 after，同时将组件中的 item 作为 slot 的一个特性绑定上去：

  【将 item 绑定在 slot 上，是为了让父级组件 ToDoList 中的插槽可以访问到该组件中的 item】

  <!-- ToDoItem.vue -->
  
  <template>
    <li>
      <span class="text-muted mr-1">{{ item.id }}.</span> {{ item.title }}
      <slot name="after" :item="item" />
    </li>
  </template>
  
  <script>
  export default {
    props: [ 'item' ]
  }
  </script>
  

• 在 ToDoList 组件中，引用 ToDoItem 的地方，嵌套 slot，修改 ToDoList.vue 如下：

  <!-- ToDoList.vue -->
  
  <template>
    <ul>
      <ToDoItem v-for="item in items" :key="item.id" :item="item">
        <template v-slot:after="{ item }">
          <slot name="todo-item-after" :item="item" />
        </template>
      </ToDoItem>
    </ul>
  </template>
  
  <script>
  import ToDoItem from './ToDoItem'
  
  export default {
    components: { ToDoItem },
    props: [ 'items' ]
  }
  </script>
  

  这里给 ToDoList 添加了一个具名插槽：todo-item-after，同时将 子组件 ToDoItem 中的具名插槽 after 所绑定的特性 item 绑定到 todo-item-after 上，这样外层的 schedule 就可以访问到 ToDoItem 中的 item了。

• 修改 schedule.vue，添加函数 isFinished 用于判断是否需要显示☑️：

  <!-- schedule.vue -->
  
  <template>
    <div class="container">
      <div class="row">
        <div class="col-md-6 offset-md-3">
          <ToDoList :items="items">
            <template v-slot:todo-item-after="{ item }">
              <i v-if="isFinished(item)" class="fas fa-check" />
            </template>
          </ToDoList>
        </div>
      </div>
    </div>
  </template>
  
  <script>
  import ToDoList from '~/components/ToDoList'
  import _ from 'lodash'
  
  export default {
    components: { ToDoList },
    data() {
      return {
        items: [
          { id: 1, title: 'todo item 1' },
          { id: 2, title: 'todo item 2' },
          { id: 3, title: 'todo item 3' },
          { id: 4, title: 'todo item 4' }
        ],
        finished: [ 4, 2 ]
      }
    },
    methods: {
      isFinished(item) {
        return _.includes(this.finished, item.id)
      }
    }
  }
  </script>
  

  如此，便完成了。

参考

插槽

写在前面

《the seasoned schemer》chapter16 中提到了Y-bang，后面给到一个biz函数，来比较两者的不同，但是作者赶着去吃炒蛋和煎饼，没有明确指出不同之处在哪里😆。

用作者的话来说，既然都能推导出Y combinator，自然也就能理解 Y 和 Y-bang 的不同​​。

After you have worked through the definition of the Y combinator, nothing will ever affect your hat size again. not even an attempt to understand the difference between Y and Yi.

既是如此，自己便试着推导了下，算是初步理清了两者的不同。

开始之前，建议在桌前备上一瓶肥仔水，你会需要它的😆。

定义

先看两者的定义：

; define Y-bang
;
(define Y-bang
  (lambda (f)
    (letrec
      ((h (f (lambda (arg) (h arg)))))
      h)))
;

; Y combinator from chapter 09, old friend.
;
(define Y
  (lambda (le)
    ((lambda (f)
      (f f))
      (lambda (f)
        (le (lambda (x)
              ((f f) x)))))))
;

推导过程

Y-bang的推导较简单，可以参看《the seasoned schemer》chapter 16 ，这里不妨再过一遍：

故事依然从length开始：

; define length
;
(define length
  (lambda (l)
    (cond
      ((null? l) 0)
      (else (add1 (length (cdr l)))))))
;

使用let 和 set! 来重新定义length:

; using let and set! to get another version of length
;
(define length
  (let ((h (lambda (l) 0)))
    (set! h
      (lambda (l)
        (cond
          ((null? l) 0)
          (else (add1 (h (cdr l)))))))
    h))
;

这里我们来定义一个函数L，用来简化这个新版本length的定义:

; define L
;
(define L
  (lambda (length)
    (lambda (l)
      (cond
        ((null? l) 0)
        (else (add1 (length (cdr l))))))))
;

这个 L 函数，接受一个函数length做为参数，返回结果是一个lambda函数。

利用 L，来简化 length：

(define length
  (let ((h (lambda (l) 0)))
    (set! h
      (L (lambda (arg) (h arg))))
    h))

如果你看懂了这步，可跳过下面的推导细节。

为什么可以这样简化？ 我们将 L 换成 定义的lambda函数：

; replace L with its definition

((lambda (length)
  (lambda (l)
    (cond
      ((null? l) 0)
      (else (add1 (length (cdr l))))))) (lambda (arg) (h arg)))
;
; replace length with (lambda (arg) (h arg)), we can get those below:

(lambda (l)
    (cond
      ((null? l) 0)
      (else (add1 ((lambda (arg) (h arg)) (cdr l))))))
;

; the result of ((lambda (arg) (h arg)) (cdr l)) is (h (cdr l))
;
(lambda (l)
    (cond
      ((null? l) 0)
      (else (add1 (h (cdr l))))))

最后得到的(L (lambda (arg) (h arg))) 的结果就是：

(lambda (l)
  (cond
   ((null? l) 0)
   (else (add1 (h (cdr l))))))

这时，替换(L (lambda (arg) (h arg))) ，得到的length如下：

(define length
  (let ((h (lambda (l) 0)))
    (set! h
      (lambda (l)
        (cond
          ((null? l) 0)
          (else (add1 (h (cdr l)))))))
    h))
;

利用新定义的length，可以推导出Y-bang.

; we get Y-bang
;
(define Y-bang
  (lambda (f)
    (letrec
      ((h (f (lambda (arg) (h arg)))))
      h)))
;

Y 稍微复杂了些 ，如果你看《the little schemer》chapter 09 时仍是懵逼状，可参考之前这篇scheme中有关Y combinator 的推导。

两者对比

当调用的函数符合一定的”模式”时，两者没什么大的区别。

看一个depth* 的例子：

; define D
;
(define D
  (lambda (depth*)
    (lambda (s)
      (cond
        ((null? s) 1)
        ((atom? (car s)) (depth* (cdr s)))
        (else
          (max
            (add1 (depth* (car s)))
            (depth* (cdr s))))))))
;

使用Y-bang 和 Y 来定义 depth*:

(define depth* (Y-bang D))

(depth* (quote (c (b (a b) a) a)))
;Value: 3

(define depth* (Y D))

(depth* (quote (c (b (a b) a) a)))
;Value: 3

使用(Y-bang D) 和 (Y D) 来定义 depth*，得到的结果相同。

来看个不一样的例子：

; define biz
;
(define biz
  (let ((x 0))
    (lambda (f)
      (set! x (add1 x))
      (lambda (a)
        (if (= a x)
            0
            (f a))))))

调用biz:

((Y biz) 5)
; Value: 0

((Y-bang biz) 5)
; no answer

此时((Y-bang biz) 5)没有结果，因为调用((Y-bang biz) 5)时，只执行了一次(set! x (add1 x)) ，x 一直是1，进入了一个无限的死循环。

为什么会是这样的？

来看一下(Y-bang biz) 是什么：

; define Y-bang
;
(define Y-bang
  (lambda (f)
    (letrec
      ((h (f (lambda (arg) (h arg)))))
      h)))
; define biz
;
(define biz
  (let ((x 0))
    (lambda (f)
      (set! x (add1 x))
      (lambda (a)
        (if (= a x)
            0
            (f a))))))
;
; now, we want know what (Y-bang biz) is.
;
; first, replace Y-bang, biz with their definition.
;
((lambda (f)
    (letrec
      ((h (f (lambda (arg) (h arg)))))
      h)) (let ((x 0))
        (lambda (f)
          (set! x (add1 x))
          (lambda (a)
            (if (= a x)
                0
                (f a))))))
;
; then, replace f with biz's definition

(letrec
  ((h ((let ((x 0))
          (lambda (f)
            (set! x (add1 x))
            (lambda (a)
              (if (= a x)
                  0
                  (f a))))) (lambda (arg) (h arg)))))
  h)
;
; and, replace f in biz with (lambda (arg) (h arg))

(letrec
  ((h ((let ((x 0))
          (lambda (f)
            (set! x (add1 x))
            (lambda (a)
              (if (= a x)
                  0
                  ((lambda (arg) (h arg)) a))))))))
  h)
;
; the result of ((lambda (arg) (h arg)) a) is (h a)
; finally, we get it.
(letrec
  ((h ((let ((x 0))
         (set! x (add1 x))
         (lambda (a)
           (if (= a x)
               0
               (h a)))))))
  h)

最后得到的结果中，可以看出，第一次调用递归函数 h 时，x 初始化为零，然后执行 add1, x 为1，此后递归时，不再执行 (lambda (a) ....) 外的表达式，x的值一直没变化，保持为1，((Y-bang biz) 5) 自然是无结果的。

我们可以测试一下，既然 x 的值一直是1，那么((Y-bang biz) 1) 应该有结果, 且为0:

((Y-bang biz) 1)
; Value: 0

我们可以修改一下biz函数，让((Y-bang biz) 5) 得到结果0。

; redefine biz
;
(define biz
  (lambda (f)
    (let ((x 0))
      (lambda (a)
        (set! x (add1 x))
        (if (= a x)
            0
            (f a))))))
;
((Y-bang biz) 5)
; Value: 0

至此，（Y-bang biz) 部分结束。

惭愧的是，一直无法推导出(Y biz) 的最终样子，将biz 的定义带入Y 中时，卡在(f f)这里，简直就是一个无限死循环。

算是一个未填的坑，留待猴年马月再填。

初步猜测(Y biz)最终的结果类似这样：

(lambda (a)
  (let ((x 0))
    (letrec
      ((h
        (lambda (a)
          (set! x (add1 x))
          (if (= a x)
              0
              (h a)))))
      (h a))))

另，这里不推荐使用pp 来输出(Y biz) 和 (Y-bang biz)的结果，因为输出的结果中，两者相同：

(pp (Y biz))

; result
;
(lambda (a)
  (if (= a x)
      0
      (f a)))

(pp (Y-bang biz))

;result
;
(lambda (a)
  (if (= a x)
      0
      (f a)))

可以看到，输出的结果中已经弃掉了(set! x (add1 x))， 使得两者看着好像是一样的，但其实并不相同，这样的结果容易误人子弟啊。

OK，Time for 🍰.

参考

《the seasoned schemer》

写在前面

《the little schemer》中的第9章，可以换一个开头：故事从一个没有名字的递归开始说起……

鉴于理解的过程蛮苦逼，记录下整个Y combinator 的推导过程，便于下次失忆的时候能迅速回忆。

不过在推导前，先来看看Y combinator 是什么。

Y combinator

wiki上的解释 fixed-point combinator 是这样的：

fix, when applied to an arbitrary function f, yields the same result as f applied to the result of applying fix to f.

细节部分太复杂了。Google 到这篇 Y Combinator的scheme 实现， 发现作者的解释看起来清楚多了，可参阅。

简单而言, 一个公式：

fix f = f (fix f) for all f

对于任意的函数f, fix 接受参数 f，返回(fix f)，将 f 作用于 (fix f)，得到的结果仍为(fix f)。

在scheme中，Y 的定义如下：

(define Y
  (lambda (le)
    ((lambda (f)
      (f f))
      (lambda (f)
        (le (lambda (x)
              ((f f) x)))))))

或者这样：

(define Y
 (lambda (F)
   (let ((W (lambda (x)
              (F (lambda arg (apply (x x) arg))))))
     (W W))))

两者其实是一样的。

来看一个调用Y的实例：

定义一个函数 Fi，用来计算斐波那契数列：【 F(1)=1，F(2)=1, F(n)=F(n-1)+F(n-2)（n>=3) 】

(define Fi
  (lambda (func-arg)
    (lambda (n)
      (cond
        ((zero? (sub1 n)) 1)
        ((zero? (- n 2)) 1)
        (else (+ (func-arg (sub1 n)) (func-arg (- n 2))))))))

然后执行：

((Y Fi) 10)
;Value: 55

((Fi (Y Fi)) 10)
;Value: 55

两次调用的输出结果相同。

推导过程

以书中定义的length函数为例：

先定义一个永远不会有值输出，死循环的函数：eternity

(define eternity
  (lambda (x)
    (eternity x)))

length的定义如下：

(define length
  (lambda (l)
    (cond
      ((null? l) 0)
      (else (add1 (length (cdr l)))))))

这里，我们定义了一个函数，命名为length，而且在该函数内部调用了它自己。

现在问题来了，如果不允许使用define来定义函数，不给函数命名，如何实现length？

我们先从最简单的 length0 开始，当 list 为空时，(length l)为 0.

先来看 length0:

; length0
;
(lambda (l)
  (cond
    ((null? l) 0)
    (else (add1 (eternity (cdr l))))))

调用时， 也很简单：

((lambda (l)
  (cond
    ((null? l) 0)
    (else (add1 (eternity (cdr l)))))) (quote ()))
;Value: 0

由此，继续定义 length<=1 ：

; length<=1
;
(lambda (l)
  (cond
    ((null? l) 0)
    (else
      (add1 (
        (lambda (l)
           (cond
             ((null? l) 0)
             (else (add1 (eternity (cdr l))))))
        (cdr l))))))

调用 length<=1 ：

((lambda (l)
  (cond
    ((null? l) 0)
    (else
      (add1 (
        (lambda (l)
           (cond
             ((null? l) 0)
             (else (add1 (eternity (cdr l))))))
        (cdr l)))))) (quote (hello)))
;Value: 1

类推 length<=2：

(lambda (l)
  (cond
    ((null? l) 0)
    (else
      (add1 (
        (lambda (l)
          (cond
            ((null? l) 0)
            (else
              (add1 (
                (lambda (l)
                   (cond
                     ((null? l) 0)
                     (else (add1 (eternity (cdr l))))))
                (cdr l))))))
          (cdr l))))))

调用 length<=2 ：

((lambda (l)
  (cond
    ((null? l) 0)
    (else
      (add1 (
        (lambda (l)
          (cond
            ((null? l) 0)
            (else
              (add1 (
                (lambda (l)
                   (cond
                     ((null? l) 0)
                     (else (add1 (eternity (cdr l))))))
                (cdr l))))))
          (cdr l)))))) (quote (hello scheme)))
;Value: 2

按照这个规律，我们可以一直定义下去，length<=n, n 为无穷大……

但这显然不是一个函数该有的样子，所以我们换一种方式，来重新定义下 length0:

; redefine length0
;
((lambda (length)
  (lambda (l)
    (cond
      ((null? l) 0)
      (else (add1 (length (cdr l)))))))
  eternity)

这里重新定义了一个函数，这个函数接受一个参数length，返回结果是一个lambda函数。

上面这段代码，调用了该函数，并将 eternity 作为参数值传递进去。与我们先前定义的 length0 没有区别，仅仅是写法不同而已。

用这种方式，可以类推出 length<=1, length<=2:

; rewrite length<=1 in the same style
;
((lambda (length)
  (lambda (l)
    (cond
      ((null? l) 0)
      (else (add1 (length (cdr l)))))))
  ((lambda (length)
    (lambda (l)
      (cond
        ((null? l) 0)
        (else (add1 (length (cdr l))))))) eternity))
;
; rewrite length<=2 in the same style
;
((lambda (length)
  (lambda (l)
    (cond
      ((null? l) 0)
      (else (add1 (length (cdr l)))))))
((lambda (length)
  (lambda (l)
    (cond
      ((null? l) 0)
      (else (add1 (length (cdr l)))))))
  ((lambda (length)
    (lambda (l)
      (cond
        ((null? l) 0)
        (else (add1 (length (cdr l))))))) eternity)))

顺着这个思路，再一次进行抽象提取，重新定义 length0:

; mk-length for length0
;
((lambda (mk-length)
    (mk-length eternity))
    (lambda (length)
      (lambda (l)
        (cond
          ((null? l) 0)
          (else (add1 (length (cdr l))))))))

这里，是将整个 length 的定义，作为 mk-length 的参数值：

它其实是同我们第二次定义的 length0 是一样的：

只是这里调用了两次，一次将整个 length 的定义，作为 mk-length 的参数值，第二次将 eternity 作为 length 的参数值。

由此可以类推出length<=1, length<=2:

; mk-length for length<=1
;
((lambda (mk-length)
    (mk-length
      (mk-length eternity)))
  (lambda (length)
    (lambda (l)
      (cond
        ((null? l) 0)
        (else (add1 (length (cdr l))))))))
;
; mk-length for length<=2
;
((lambda (mk-length)
  (mk-length
    (mk-length
      (mk-length eternity))))
  (lambda (length)
    (lambda (l)
      (cond
        ((null? l) 0)
        (else (add1 (length (cdr l))))))))

这里，eternity 扮演的是参数值的角色，它本身是一个函数，我们使用 mk-length 来替换掉 eternity，当然也是可以的，重新看一下替换掉eternity后的 length0 :

; replace eternity with mk-length
;
((lambda (mk-length)
    (mk-length mk-length))
    (lambda (length)
      (lambda (l)
        (cond
          ((null? l) 0)
          (else (add1 (length (cdr l))))))))

这里，length也不过是一个参数名，自然也是可以换成mk-length的。

; using mk-length instead of length
;
((lambda (mk-length)
    (mk-length mk-length))
    (lambda (mk-length)
      (lambda (l)
        (cond
          ((null? l) 0)
          (else (add1 (mk-length (cdr l))))))))

现在，调用上面这个函数，将eternity作为参数值，我们可以得到 length<=1:

; apply mk-length to get length<=1
;
((lambda (mk-length)
    (mk-length mk-length))
    (lambda (mk-length)
      (lambda (l)
        (cond
          ((null? l) 0)
          (else (add1 ((mk-length eternity) (cdr l))))))))

这里稍稍有点绕，截个图就明白了：

调用一次试试看：

(((lambda (mk-length)
    (mk-length mk-length))
    (lambda (mk-length)
      (lambda (l)
        (cond
          ((null? l) 0)
          (else (add1 ((mk-length eternity) (cdr l)))))))) (quote (apple)))
;Value: 1

结果无误。

现在，我们再将上面 length<=1定义中 的 eternity 替换成 mk-length:

; replace eternity with mk-length
;
((lambda (mk-length)
    (mk-length mk-length))
    (lambda (mk-length)
      (lambda (l)
        (cond
          ((null? l) 0)
          (else (add1 ((mk-length mk-length) (cdr l))))))))

鉴于(f x) 与 (lambda (x) (f x)) 是一样的，所以我们使用((lambda (x) ((mk-length mk-length) x)) (cdr l)) 来替换掉((mk-length mk-length) (cdr l))。

替换后的结果如下：

((lambda (mk-length)
    (mk-length mk-length))
    (lambda (mk-length)
      (lambda (l)
        (cond
          ((null? l) 0)
          (else (add1 ((lambda (x) ((mk-length mk-length) x)) (cdr l))))))))

再来一次抽取，将(lambda (x) ((mk-length mk-length) x)) 作为参数值提取出来：

((lambda (mk-length)
    (mk-length mk-length))
    (lambda (mk-length)
      ((lambda (length)
        (lambda (l)
          (cond
            ((null? l) 0)
            (else (add1 (length (cdr l)))))))
        (lambda (x) ((mk-length mk-length) x)))))

你会发现最初定义length的那段代码已经完整浮现了：

最后一次，将整块length的定义作为参数值，提取出来：

((lambda (le)
  ((lambda (mk-length)
    (mk-length mk-length))
    (lambda (mk-length)
      (le (lambda (x)
            ((mk-length mk-length) x))))))
 (lambda (length)
  (lambda (l)
    (cond
      ((null? l) 0)
      (else (add1 (length (cdr l))))))))

这段代码中，将：

 (lambda (length)
  (lambda (l)
    (cond
      ((null? l) 0)
      (else (add1 (length (cdr l)))))))

作为了le的参数值。

现在，我们移除掉这个参数值，得到如下代码：

(lambda (le)
  ((lambda (mk-length)
    (mk-length mk-length))
    (lambda (mk-length)
      (le (lambda (x)
            ((mk-length mk-length) x))))))

好了，我们可以撒花🎉啦。

用 f 替换 mk-length，Y combinator 登场：

; Y combinator
;
(define Y
  (lambda (le)
    ((lambda (f)
      (f f))
      (lambda (f)
        (le (lambda (x)
              ((f f) x)))))))

整个推导过程结束。

另，Peter Krumins 有一篇文章也详细演示了Y combinator的推导过程，可参阅 Deriving the Y-Combinator。

参考

fixed-point combinator.

Y Combinator的scheme 实现

《The little schemer》

写在前面

collector出现在《 the little schemer》chapter 08中，刷了两遍才算勉强理解，记录下。

collector 的运用，对应着《 the little schemer》中提到了第10戒：Build functions to collect more than one value at a time. 简单理解为创建函数，一次收集多个值，然后对这些值进行再处理。

看个例子，加深对collector的理解。

代码演示

根据《the little schemer》chapter 08 中给出的奇偶数例子稍稍加以改编。

定义函数 number-only*&co，给到一个list， 要求：找出这个list中的所有数字，并求出数字的总和。将总和和新的数字集一并输出。

比如：

; 输出结果的格式（sum newlist), list的第一个元素是求和的结果，第二个元素为所取到数字集。
;
(number-only*&co (quote (9 apples 2 oranges 10 peaches 11 pears)) cal-number)
;Value : (32 (9 2 10 11))

(number-only*&co (quote (9 apples (2 oranges) (10) peaches ((11)) pears)) cal-number)
;Value : (32 (9 (2) (10) ((11))))

这里cal-number 就是一个collector。

来看number-only*&co 和 cal-number的定义：

; define number-only*&co
;
(define number-only*&co
  (lambda (l col)
    (cond
      ((null? l) (col (quote ()) 0))
      ((atom? (car l))
      (cond
        ((number? (car l))
         (number-only*&co (cdr l)
          (lambda (newlat s)
            (col (cons (car l) newlat) (+ (car l) s)))))
        (else (number-only*&co (cdr l) col))))
      (else (number-only*&co (car l)
                           (lambda (al as)
                            (number-only*&co (cdr l)
                              (lambda (dl ds)
                                (col (cons al dl) (+ as ds))))))))))
;
; define cal-number
;
(define cal-number
  (lambda (l s)
    (cons s (cons l (quote ())))))
;

简单解释下：

number-only*&co 接受两个参数，一个是list，一个是collector。

collector接受两个参数，一个是newlist, 一个是 s (s is short for sum)， newlist用来存 l 中的数字，s用来存数字求和的结果。

collector的初始值是col((quote ()) 0)，也就是newlist 为空，s为0，理解这一点很重要。

• 当 l 是空的 list 时，number-only*&co的结果就是 (col (quote ()) 0).

• 当 l 不为空时，判断 l 的第一个元素是不是一个atom:

  • (atom? (car l)) 为 #t, 判断第一个元素是不是number：

    • 第一个元素是number，添加到newlist里面，同时s = s + (car l)。此时新的collector长这样:

      (lambda (newlat s)
         (col (cons (car l) newlat) (+ (car l) s)))
      

    • 第一个元素不是number，那就什么也不做，collector不变，仍然为col。

  • (atom? (car l)) 为 #f:

    这里就要定义 (car l) 后的collector了。这个collector需要使用number-only*&co 来遍历 (cdr l)，挑出(cdr l)中的所有数字，并算出这些数字的和。所以，它应该长成这样：

    (lambda (al as)
      (number-only*&co (cdr l)
         (lambda (dl ds)
              ......)))
    

    「这里al, as 是 number-only*&co 处理(car l) 时得到的结果，而dl, ds 是 number-only*&co 处理 (cdr l) 时得到的结果。」

    有了al, dl, as, ds， 后面只需要将两者得到的结果整合起来即可。

    所以，else语句中，最后的collector长这样：

    (lambda (al as)
      (number-only*&co (cdr l)
        (lambda (dl ds)
          (col (cons al dl) (+ as ds)))))
    

至此， number-only*&co 的定义完成。

而cal-number 仅仅是一个collector，返回(sum newlist)， 没什么特别的。

也可以定义新的collector，比如只返回sum，或者只返回newlist。

(define sum-number
  (lambda (l s)
    s))
;
(define number-list
  (lambda (l s)
    l))

然后调用的时候，使用新的collector：

(number-only*&co (quote (9 apples (2 oranges) (10) peaches ((11)) pears)) sum-number)
;Value: 32

(number-only*&co (quote (9 apples (2 oranges) (10) peaches ((11)) pears)) number-list)
;Value : (9 (2) (10) ((11)))

OK。算是又刷了一遍，可以开启下一章的旅途了。

参考

《The little schemer》

写在前面

在nuxt中添加plugins时，遇到的问题，Google了大半天才解决，记录下以备忘。

问题描述

自定义plugins，里面引用了jquery，比如pluginA.js：

// plugins/pluginA.js
import $ from 'jquery'
export default function({ app }) {
  .....
  $('body').append("<div>hello</div>")
  .....
}

修改nuxt.config.js文件，将pluginA.js 加入到plugings中：

// nuxt.config.js

plugins: [
   '~/plugins/pluginA'
]

重启后，一直报错：

document is not defined

或者

jQuery requires a window with a document

解决方法

官网window or document undefined? 部分给到了解释：

This is due to the server-side rendering. If you need to specify that you want to import a resource only on > > the client-side.

查看文档plugins ， 在 Client-side only部分给到了解决方法，使用option：ssr: false

修改nuxt.config.js文件：

// nuxt.config.js

plugins: [
   { src: '~/plugins/pluginA', ssr: false }
]

重启，OK.

参考

plugins Client-side only

window or document undefined?

Use jquery error “jQuery requires a window with a document”!

在Mac下执行Lisp程序时，遇到了点坑，记录下。

这里的Lisp主要是指common lisp和scheme。

Common lisp

如何在终端跑common lisp文件？
common lisp wiki 上给出了很多免费的implementations。

如：Armed Bear Common Lisp (ABCL) ，Clozure CL(CCL), Embeddable Common Lisp(ECL), Steel Bank Common Lisp (SBCL) 。

这里，我选了SBCL。

先安装SBCL：

brew install sbcl

执行某个文件：

sbcl --script FILENAME

执行sbcl --help， 了解更多。

更新[2019-03-29]：

练习common lisp的时候，想试试在终端运行指令，类似mit-scheme，发现sbcl没那么顺手，改用clisp。

安装:

brew install clisp

安装后，终端直接 clisp， 进入交互环境。

使用 (exit) 或者 (quit) 退出clisp。

执行某个文件：

clisp FILENAME

执行clisp --help， 了解更多。

Scheme

参考mit-scheme, 下载MIT-scheme:

[对于Mac OS version 10.14 +，请不要直接在mit-scheme下载适用于Mac OS 10.13的安装包，会坑得人莫名其妙……]

使用Homebrew：

brew install mit-scheme

安装完成后，终端输入：

mit-scheme

进入scheme交互环境:

使用 (exit) 或者 (quit) 退出scheme。

执行某个文件：

scheme < FILENAME

执行scheme --help， 了解更多。

At last, Thanks, Homebrew, you saved me.

参考

common lisp wiki

SBCL

MIT/GUN Scheme

正文

读完就觉得很喜欢，非常愿意把它推荐给身边的朋友，不管TA是否懂编程。

全书共15章，章章之间并没有很强的逻辑关联。就挑一些自己印象深刻的写一写。

有关lisp

书中多次提到了lisp，并认为这是一门非常值得去学习的语言，虽然在工作中你可能很少使用到它。

Lisp is worth learning for the profound enlightment experience you will have when you finally get it; that experience will make you a better programmer for the rest of your days, even if you never actually use Lisp itself a lot.

特意在GitHub上搜了下，有关common lisp的项目并不多，而sbcl截止目前的star竟然1K都不到，这个诞生于1958年的古老语言已经退出主流语言的阵营。

在lisp wiki 里，提到目前Lisp的两大主流方言是common lisp 和scheme，两者的语法有些不一样。

初学者容易懵，学哪个？有什么参考书籍推荐？Paul Graham在他自己的blog Lisp FAQ里面给了回复：

Which should I learn, Common Lisp or Scheme? What’s the difference?

Common Lisp is powerful but ugly. Scheme is small and clean, but the standard only defines the inner core of the language. If I had to deliver an application I’d probably use Common Lisp; if I were teaching a course I might use Scheme (but with Common Lisp macros).

同时也给出了学习common lisp的参考书籍：正是他本人操刀的那本《ansi common lisp》。

此外，Google有一个lisp-koan， 2K多star，用于练习common lisp。

如果你使用atom编辑器，练习lisp-koan时，推荐下载package： language-lisp，代码敲起来会舒服很多。

上面都是说common lisp，来看看scheme。

GitHub上找到的有关scheme的项目中，比较醒目的是思科的ChezScheme, 但它并不是纯粹的scheme，C的身影处处可见。

相比common lisp，你会发现scheme的语法看着更清爽，更舒服。

如果想了解scheme的话，强烈推荐Daniel P.Friedman和Matthias Felleisen的那本《The little schemer》，最新版本是第4版，呃，貌似应该不会有更新了。整本书写得非常通俗易懂，作者还会时不时的幽默下，对于我这样完全的Lisp小白来说，这种风格的书籍不要太友好啊。

有关hacker

我记得很久之前看过一个纪录片系列：《互联网时代》，里面采访了一些计算机界的大牛们，大多已经年老，看的时候会觉得这些人真的很伟大，像上古时代那些开疆拓土的英雄们，硬生生辟出了一个完全不一样的时代，撬动一个点，真的改变了整个世界。陡然生出一种脑残粉式的崇拜。

Raymond在How to become a Hacker上写了一系列很经典的文章，其中有一首Zen诗：

to follow the path
look to the master
follow the master
walk with the master
see through the master
become the master

可站在金字塔尖儿的master毕竟是少数，大部分是小花小草，不过小花小草也是可以仰望参天，努力成长的嘛。

牛逼也是时间积累出来的。

作者本人做为一名hacker，在书中并没有什么说教的内容，倒是实实在在的说了些自己知道的，特别是第三章-不能说的话，能把大实话这么说出来的，还真的挺需要勇气的，当然，这也许跟作者当时已经把Viaweb卖了有关，没卖之前他应该还是会有所顾忌吧。

很喜欢第三章的结尾处那段话，阮一峰老师翻译得也很好：

Everyone encourages you to grow up to the point where you can discount your own bad moods. Few encourages you to continue to the point where you can discount society’s bad moods.
小时候，每个人都会鼓励你不断成长，变成一个心智成熟，不再耍小孩子脾气的人。但是，没有人鼓励你继续成长，变成一个怀疑和抵制社会错误潮流的人。

变成一个怀疑和抵制社会错误潮流的人很难，毕竟，独立思考本身就不是一件轻松的事。

书中有些章节看得还挺鸡汤的，很客观很现实，比如下面这碗：

In our world, you sink or swim, and there are no excuses.
我们这个世界，你向下沉沦或者向上奋进都取决于你自己，不能把原因推给别人。

汤味浓郁，喝完很滋补。

后记

之前写读书笔记，我都会顺着章节一一总结，比如这本，常规整理思路会是这样：

本书一共xxx章，每章主要说了xxx。这一章xxxx最让我印象深刻。

最典型的例子就是之前整理《beyond feelings》。

这样的整理方式，唯一的好处大概就是帮助回忆，让人迅速对每一章的内容建起一个大致的轮廓，但是，这样整理下来后，满屏的文字读起来费劲不说，更让我在事后回看时，不知道重点在哪。

我开始反感这样的方式。

所以这次只记录读后的感觉，脑子里能回想起来的内容，其他略去。

这样想之后，写起来就顺了很多。

某种程度上，也算是一种变相的偷懒了。

Paul Graham在书中提过这么一句：如果你有两个选择，那就选择较难的那个。

但他也说了：并非所有的艰苦都是值得的。

所以，呃，或许，选择更适合的那一个也不错。

参考

lisp wiki>)

how to become a hacker

Paul Graham essays