BlogJava-庄周梦蝶-随笔分类-计算机科学与基础

演示TCP慢启动和滑动窗口机制的动画

dennis — Tue, 15 Nov 2011 23:34:00 GMT

今天看到的一个演示TCP慢启动和滑动窗口机制的动画，很形象
osischool.com

dennis 2011-11-16 07:34 发表评论

高性能EL——Fel探秘，兼谈EL

dennis — Sat, 17 Sep 2011 04:52:00 GMT

Fel是最近javaeye比较火的关键词，这是由网友lotusyu开发的一个高性能的EL，从作者给出的数据来看，性能非常优异，跟前段时间温少开源的Simple EL有的一拼。首先要说，这是个好现象，国内的开源项目越来越多，可以看出开发者的水平是越来越高了，比如我最近还看到有人开源的类似kestel的轻量级MQ——fqueue也非常不错，有兴趣可以看下我的分析《fqueue初步分析》。

进入正文，本文是尝试分析下Fel的实现原理，以及优缺点和aviator——我自己开源的EL之间的简单比较。

Fel的实现原理跟Simple EL是类似，都是使用template生成中间代码——也就是普通的java代码，然后利用javac编译成class，最后运行，当然，这个过程都是动态的。JDK6已经引入了编译API，在此之前的版本可以调用sun的类来编译，因为javac其实就是用java实现的。回到Fel里面，FelCompiler15就是用 com.sun.tools.javac.Main来编译，而FelCompiler16用标准的javax.tools.JavaCompiler来编译的。

文法和语法解释这块是使用antlr这个parse generator生成的，这块不多说，有兴趣可以看下antlr，整体一个运行的过程是这样：

expression string -> antlr -> AST -> comiple -> java source template -> java class -> Expression

这个思路我在实现aviator之前就想过，但是后来考虑到API需要用的sun独有的类，而且要求classpath必须有tools.jar这个依赖包，就放弃了这个思路，还是采用ASM生成字节码的方式。题外，velocity的优化可以采用这个思路，我们有这么一个项目是这么做的，也准备开源了。

看看Fel生成的中间代码，例如a+b这样的一个简单的表达式，假设我一开始不知道a和b的类型，编译是这样：

FelEngine fel = new FelEngineImpl();
Expression exp = fel.compile("a+b", null);

我稍微改了下FEL的源码，让它打印中间生成的java代码，a+b生成的中间结果为：

    package com.greenpineyu.fel.compile;

    import com.greenpineyu.fel.common.NumberUtil;
    import com.greenpineyu.fel.Expression;
    import com.greenpineyu.fel.context.FelContext;
    import org.apache.commons.lang.ObjectUtils;
    import org.apache.commons.lang.StringUtils;

    public class Fel_0  implements Expression{

        public Object eval(FelContext context) {
            java.lang.Object var_1 = (java.lang.Object)context.get("b");   //b
            java.lang.Object var_0 = (java.lang.Object)context.get("a");   //a
            return (ObjectUtils.toString(var_0))+(ObjectUtils.toString(var_1));
        }
    }

可见，FEL对表达式解析和解释后，利用template生成这么一个普通的java类，而a和b都从context中获取并转化为Object类型，这里没有做任何判断就直接认为a和b是要做字符串相加，然后拼接字符串并返回。

问题出来了，因为没有在编译的时候传入context（我们这里是null），FEL会将a和b的类型默认都为java.lang.Object，a+b解释为字符串拼接。但是运行的时候，我完全可以传入a和b都为数字，那么结果就非常诡异了：

     FelEngine fel = new FelEngineImpl();

    Expression exp = fel.compile("a+b", null);
    Map<String, Object> env=new HashMap<String, Object>();
    env.put("a", 1);
    env.put("b", 3.14);
    System.out.println(exp.eval(new MapContext(env)));

输出：

13.14

1+3.14的结果，作为字符串拼接就是13.14，而不是我们想要的4.14。如果将表达式换成a*b，就完全运行不了

    com.greenpineyu.fel.exception.CompileException: package com.greenpineyu.fel.compile;

    import com.greenpineyu.fel.common.NumberUtil;
    import com.greenpineyu.fel.Expression;
    import com.greenpineyu.fel.context.FelContext;
    import org.apache.commons.lang.ObjectUtils;
    import org.apache.commons.lang.StringUtils;

    public class Fel_0  implements Expression{

        public Object eval(FelContext context) {
            java.lang.Object var_1 = (java.lang.Object)context.get("b");   //b
            java.lang.Object var_0 = (java.lang.Object)context.get("a");   //a
            return (var_0)*(var_1);
        }
    }

    [Fel_0.java:14: 运算符 * 不能应用于 java.lang.Object,java.lang.Object]
        at com.greenpineyu.fel.compile.FelCompiler16.compileToClass(FelCompiler16.java:113)
        at com.greenpineyu.fel.compile.FelCompiler16.compile(FelCompiler16.java:87)
        at com.greenpineyu.fel.compile.CompileService.compile(CompileService.java:66)
        at com.greenpineyu.fel.FelEngineImpl.compile(FelEngineImpl.java:62)
        at TEst.main(TEst.java:14)
    Exception in thread "main" java.lang.NullPointerException
        at TEst.main(TEst.java:18)

这个问题对于Simple EL同样存在，如果没有在编译的时候能确定变量类型，这无法生成正确的中间代码，导致运行时出错，并且有可能造成非常诡异的bug。

这个问题的本质是因为Fel和Simple EL没有自己的类型系统，他们都是直接使用java的类型的系统，并且必须在编译的时候确定变量类型，才能生成高效和正确的代码，我们可以将它们称为“强类型的EL“。

现在让我们在编译的时候给a和b加上类型，看看生成的中间代码：

    FelEngine fel = new FelEngineImpl();
    fel.getContext().set("a", 1);
    fel.getContext().set("b", 3.14);
    Expression exp = fel.compile("a+b", null);
    Map<String, Object> env = new HashMap<String, Object>();
    env.put("a", 1);
    env.put("b", 3.14);
    System.out.println(exp.eval(new MapContext(env)));

查看中间代码：

    package com.greenpineyu.fel.compile;

    import com.greenpineyu.fel.common.NumberUtil;
    import com.greenpineyu.fel.Expression;
    import com.greenpineyu.fel.context.FelContext;
    import org.apache.commons.lang.ObjectUtils;
    import org.apache.commons.lang.StringUtils;

    public class Fel_0  implements Expression{

        public Object eval(FelContext context) {
            double var_1 = ((java.lang.Number)context.get("b")).doubleValue();   //b
            double var_0 = ((java.lang.Number)context.get("a")).doubleValue();   //a
            return (var_0)+(var_1);
        }
    }

可以看到这次将a和b都强制转为double类型了，做数值相加，结果也正确了：

4.140000000000001

Simple EL我没看过代码，这里猜测它的实现也应该是类似的，也应该有同样的问题。

相比来说，aviator这是一个弱类型的EL，在编译的时候不对变量类型做任何假设，而是在运行时做类型判断和自动转化。过去提过，我给aviator的定位是一个介于EL和script之间的东西，它有自己的类型系统。例如，3这个数字，在java里可能是long,int,short,byte，而aviator统一为AviatorLong这个类型。为了在这两个类型之间做适配，就需要做很多的判断和box,unbox操作。这些判断和转化都是运行时进行的，因此aviator没有办法做到Fel这样的高效，但是已经做到至少跟groovy这样的弱类型脚本语言一个级别，也超过了JXEL这样的纯解释EL，具体可以看这个性能测试。

强类型还是弱类型，这是一个选择问题，如果你能在运行前就确定变量的类型，那么使用Fel应该可以达到或者接近于原生java执行的效率，但是失去了灵活性；如果你无法确定变量类型，则只能采用弱类型的EL。

EL涌现的越来越多，这个现象有点类似消息中间件领域，越来越多面向特定领域的轻量级MQ的出现，而不是原来那种大而笨重的通用MQ大行其道，一方面是互联网应用的发展，需求不是通用系统能够满足的，另一方面我认为也是开发者素质的提高，大家都能造适合自己的轮子。从EL这方面来说，我也认为会有越来越多特定于领域的，优点和缺点一样鲜明的EL出现，它们包含设计者自己的目标和口味，选择很多，就看取舍。

dennis 2011-09-17 12:52 发表评论

Scheme interpreter in clojure

dennis — Mon, 24 Jan 2011 02:42:00 GMT

昨天晚上用clojure搞了个scheme解释器，基本上是sicp里的解释器的clojure翻译版本，可能唯一值的一提的是对transient集合的使用，实现副作用的set!。总共代码包含注释才366行，支持的feature包括

Feature	Supported	Comment
define	yes
lambda	yes
variable lookup	yes
primitive procedure evaluation	yes
compound procedure evaluation	yes	no tail recursion yet
if	yes
cond	yes
let	yes
let*	yes	no named let* yet
letrec	no
begin	yes
set!	yes
quote	yes
quasiquote	no
unquote	no
delay	no
define-syntax	no

支持的primitive procedure包括常见的四则运算、car/cdr、list以及display、newline等。代码放在了github上：https://github.com/killme2008/cscheme,有兴趣的可以玩玩吧。

dennis 2011-01-24 10:42 发表评论

一道面试题注记

dennis — Thu, 28 Oct 2010 02:53:00 GMT

javaeye的一个帖子介绍一道面试题，取数组的最大元素和前n个大元素，取最大元素很简单，遍历即可。取前N大元素，可以利用排序，最简单的实现：

    public static int[] findTopNValues(int[] anyOldOrderValues, int n) {
        Arrays.sort(anyOldOrderValues);
        int[] result = new int[n];
        System.arraycopy(anyOldOrderValues, anyOldOrderValues.length - n,
                result, 0, n);
        return result;
    }

Arrays.sort(int[])使用的是快排，平均的时间复杂度是O( n lg(n))，在一般情况下已经足够好。那么有没有平均情况下O(n)复杂度的算法？这个还是有的，这道题目其实是选择算法的变形，选择一个数组中的第n大元素，可以采用类似快排的方式划分数组，然后只要在一个子段做递归查找就可以，平均状况下可以做到O(n)的时间复杂度，对于这道题来说稍微变形下算法即可解决：

    /**
     * 求数组的前n个元素
     *
     * @param anyOldOrderValues
     * @param n
     * @return
     */
    public static int[] findTopNValues(int[] anyOldOrderValues, int n) {
        int[] result = new int[n];
        findTopNValues(anyOldOrderValues, 0, anyOldOrderValues.length - 1, n,
                n, result);
        return result;
    }

    public static final void findTopNValues(int[] a, int p, int r, int i,
            int n, int[] result) {
        // 全部取到，直接返回
        if (i == 0)
            return;
        // 只剩一个元素，拷贝到目标数组
        if (p == r) {
            System.arraycopy(a, p, result, n - i, i);
            return;
        }
        int len = r - p + 1;
        if (i > len || i < 0)
            throw new IllegalArgumentException();
        // if (len < 7) {
        // Arrays.sort(a, p, r+1);
        // System.arraycopy(a, r - i+1 , result, n - i, i);
        // return;
        // }

        // 划分
        int q = medPartition(a, p, r);
        // 计算右子段长度
        int k = r - q + 1;
        // 右子段长度恰好等于i
        if (i == k) {
            // 拷贝右子段到结果数组，返回
            System.arraycopy(a, q, result, n - i, i);
            return;
        } else if (k > i) {
            // 右子段比i长，递归到右子段求前i个元素
            findTopNValues(a, q + 1, r, i, n, result);
        } else {
            // 右子段比i短，拷贝右子段到结果数组，递归左子段求前i-k个元素
            System.arraycopy(a, q, result, n - i, k);
            findTopNValues(a, p, q - 1, i - k, n, result);
        }
    }

    public static int medPartition(int x[], int p, int r) {
        int len = r - p + 1;
        int m = p + (len >> 1);
        if (len > 7) {
            int l = p;
            int n = r;
            if (len > 40) { // Big arrays, pseudomedian of 9
                int s = len / 8;
                l = med3(x, l, l + s, l + 2 * s);
                m = med3(x, m - s, m, m + s);
                n = med3(x, n - 2 * s, n - s, n);
            }
            m = med3(x, l, m, n); // Mid-size, med of 3
        }
        if (m != r) {
            int temp = x[m];
            x[m] = x[r];
            x[r] = temp;
        }
        return partition(x, p, r);
    }

    private static int med3(int x[], int a, int b, int c) {
        return x[a] < x[b] ? (x[b] < x[c] ? b : x[a] < x[c] ? c : a)
                : x[b] > x[c] ? b : x[a] > x[c] ? c : a;
    }

    public static void swap(int[] a, int i, int j) {
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

    public static int partition(int a[], int p, int r) {
        int x = a[r];
        int m = p - 1;
        int j = r;
        while (true) {
            do {
                j--;
            } while (j>=p&&a[j] > x);
            do {
                m++;
            } while (a[m] < x);

            if (j < m)
                break;
            swap(a, m, j);
        }
        swap(a, r, j + 1);
        return j + 1;
    }

选择算法还有最坏情况下O(n)复杂度的实现，有兴趣可以读算法导论和维基百科。题外，我测试了下这两个实现，在我的机器上大概有2倍多的差距，还是很明显。

dennis 2010-10-28 10:53 发表评论

Actor、Coroutine和Continuation的概念澄清

dennis — Tue, 23 Mar 2010 03:49:00 GMT

Actor、Coroutine和Continuation这三个概念由于并发的受关注而被经常提到，这里主要想谈下这三者的区别和联系，以便更好的区分问题领域和讨论。首先，Actor和Coroutine在我看来是两种并发模型，仅针对于并发这个领域，而Continuation则是程序设计领域的一个概念，相比于Actor和Coroutine是一个更基础的概念。

那么，什么是Continuation？这个要从表达式的求值说起。一个表达式的求值可以分为两个阶段：“What to evaluate?”和“What to do with the value”，“What to do with the value”就是计算的Continuation。以下面这段代码为例：

if x<3 then
return x+1
else
return x
end

考察其中的表达式x<3，这个表达式就是“what to evaluate?”，代表你将计算的东西，然后根据x<3的结果决定是执行x+1还是直接返回x，这个根据x<3的值来决定下一步的过程就是这个表达式的Continuation，也就是"what to do with the value"。怎么得到某个表达式的Continuation呢？在支持Continuation的语言里提供了call-with-current-continuation的函数，通常简称为call/cc，使用这个函数你就可以在任何代码中得到Continuation。进一步，continuation有什么作用呢？它可以做的事情不少，如nonlocal exits、回溯、多任务的实现等等。例如在scheme中没有break语句，就可以用call/cc实现一些此类高级的控制结构：

(call/cc (lambda (break)
        (for-each (lambda (x) (if (< x 0) (break x)))
                '(99 88 -77 66 55))
        #t))

    上面这段代码查找列表(99 88 -77 66 55)中的负数，当查找到的时候马上从迭代中退出并返回该值，其中的break就是一个continuation。刚才还提到continuation可以实现回溯，那么就可以实现一个穷举的机器出来用来搜索解空间，也就是类似Prolog中的回溯机制，在SICP这本书里就介绍了如何用call/cc实现一个简单的逻辑语言系统。更著名的就是神奇的amb操作符，有兴趣可以看看这里。

     接下来我们来看看如何continuation实现多任务，在Continuation的维基百科里给了一段代码来展示如何用scheme来实现coroutine，我稍微修改了下并添加了注释:

;;continuation栈，保存了等待执行的continuation
(define call/cc call-with-current-continuation)
(define *queue* '())

(define (empty-queue?)
        (null? *queue*))

(define (enqueue x)
        (set! *queue* (append *queue* (list x))))

(define (dequeue)
        (let ((x (car *queue*)))
              (set! *queue* (cdr *queue*))
         x))
;;启动协程
(define (resume proc)
       (call/cc
         (lambda (k)
           ;;保存当前continuation，执行proc
           (enqueue k)
           (proc))))
;;让出执行权
(define (yield)
     (call/cc
      (lambda (k)
         ;;保存当前continuation，弹出上一次执行的cont并执行
        (enqueue k)
        ((dequeue)))))
;;停止当前协程或者当没有一个协程时停止整个程序,最简单的调度程序
(define (thread-exit)
     (if (empty-queue?)
         (exit)
         ((dequeue))))

（注：scheme以分号开头作为注释）

这其实就是一个coroutine的简单实现，context的保存、任务的调度、resume/yield原语……样样俱全。使用起来类似这样，下面这段程序轮流打印字符串：

(define (display-str str)
        (lambda()
         (let loop()
              (display str)
              (newline)
              (yield)
              (loop))))

;;;创建两个协程并启动调度器
(resume (display-str "This is AAA"))
(resume (display-str "Hello from BBB"))
(thread-exit)

任务非常简单，打印下传入的字符串并换行，然后让出执行权给另一个任务执行，因此输出：

This is AAA
Hello from BBB
This is AAA
Hello from BBB
This is AAA
Hello from BBB
This is AAA
Hello from BBB
……

    谈了这么多continuation的应用，事实上我想说明的是continuation可以用来实现协程，Ruby 1.9中call/cc和Fiber的实现（在cont.c)大体是一样的同样说明了这一点。

     接下来我们讨论下Actor和Coroutine的关系，上面提到Actor是一种并发模型，我更愿意称之为一种编程风格，Actor跟message passing、Duck Typing是一脉相承的。Actor风格是可以这么描述：将物理世界抽象成一个一个的Actor，Actor之间通过发送消息相互通信，Actor不关心消息是否能被接收或者能否投递到，它只是简单地投递消息给其他actor，然后等待应答。Actor相比于Coroutine是一种更高层次的抽象，它提供的receive和pattern match的原语更接近于现实世界，而使用coroutine编程你还需要手工介入任务调度，这在Actor中是由一个调度器负责的。

    同样，Actor可以用coroutine实现，例如Ruby有个revactor项目，就是利用1.9引入的Fiber实现actor风格的编程，它的实现非常简单，有兴趣地可以看看，其实跟continuation实现coroutine类似。但是Actor并不是一定要用coroutine才能实现，Actor是一种编程风格，你在Java、C#、C++中同样可以模拟这样的方式去做并发编程，.net社区的老赵实现过一个简单的Actor，Scala的Actor实现是基于外部库，利用scala强大的元编程能力使得库的使用像内置于语言。

    总结下我想表达的：Continuation是程序设计领域的基础概念，它可以用于实现coroutine式的多任务，Actor是一种比之coroutine更为抽象的编程风格，Actor可以基于Coroutine实现但并非必须，Actor和Coroutine都是现在比较受关注的并发模型。

dennis 2010-03-23 11:49 发表评论

《Unix编程艺术》重读笔记(三)

dennis — Sun, 21 Feb 2010 16:46:00 GMT

题外：从老家从早到晚总算折腾回了杭州，进站太早，火车晚点，提包带断，什么倒霉事也遇上了，先发个已经整理好的部分，后续仍待整理。

多道程序设计：分离进程为独立的功能

无论在协作进程还是在同一进程的协作子过程层面上，Unix设计风格都运用“做单件事并做好的方法“，强调用定义良好的进程间通信或共享文件来连通小型进程，提倡将程序分解为更简单的子进程，并专注考虑这些子进程间的接口，这至少需要通过以下三种方法来实现：

1、降低进程生成的开销(思考下Erlang的process)

2、提供方法（shellout、IO重定向、管道、消息传递和socket）简化进程间通信

3、提倡使用能由管道和socket传递的简单、透明的文本数据格式

Unix IPC方法的分类：

1、将任务转给专门程序，如system(3)，popen调用等，称为shellout

2、Pipe、重定向和过滤器，如bc和dc

3、包装器，隐藏shell管线的复杂细节。

4、安全包装器和Bernstein链

5、主/从进程

6、对等进程间通信：

(1)临时文件

(2)信号

(3)系统守护程序和常规信号

(4)socket

(5)共享内存，mmap

远程过程调用(RPC)的缺憾：

1、RPC接口很难做到可显，如果不编写和被监控程序同样复杂的专用工具，也难以监控程序的行为。RPC接口和库一样具有版本不兼容的问题，由于是分布式的，因此更难被追查。

2、类型标记越丰富的接口往往越复杂，因而越脆弱。随着时间的推移，由于在接口之间传递的类型总量逐渐变大，单个类型越来越复杂，这些接口往往产生类型本体蠕变问题。这是因为接口比字符串更容易失配；如果两端程序的本体不能正确匹配，要让它们通信肯定很难，纠错更是难上加难。

3、支持RPC的常见理由是它比文本流方法允许“更丰富”的接口，但是接口的功能之一就是充当阻隔点，防止模块的实现细节彼此泄漏，因此，支持RPC的主要理由同时恰恰证明了RPC增加而不是降低了程序的全局复杂度。

Unix传统强烈赞成透明、可显的接口，这是unix文化不断坚持文本协议IPC的动力。

ESR在这里还谈到XML-RPC和SOAP等协议，认为是RPC和unix对文本流支持的一种融合，遗憾的是SOAP本身也成为一种重量级、不那么透明的协议了，尽管它也是文本协议。

线程是有害的：

线程是那些进程生成昂贵、IPC功能薄弱的操作系统所特有的概念。

尽管线程通常具有独立的局部变量栈，它们却共享同一个全局内存，在这个共享地址空间管理竞争和临界区的任务相当困难，而且成为增加整体复杂度和滋生bug的温床。除了普通的竞争问题之外，还产生了一类新问题：时序依赖。

当工具的作用不是控制而是增加复杂度的时候，最好扔掉从零开始。

微型语言：寻找歌唱的乐符

（注，这里谈的微型语言，就是现在比较热门的词汇DSL）

对软件错误模式进行的大量研究得出的一个最一致的结论是，程序员每百行程序出错率和所使用的编程语言在很大程度上是无关的。更高级的语言可以用更少的行数完成更多的任务，也意味着更少的bug。

防御设计不良微型语言的唯一方法是知道如何设计一个好的微型语言。

语言分类法：

对微型语言的功能测试：不读手册可以编写吗？

现代微型语言，要么就完全通用而不紧凑，要么就非常不通用而紧凑；不通用也不紧凑的语言则完全没有竞争力。

一些引申想法：我认为这个评判标准也可以用在任何编程语言上，以此来判断一些语言，C语言既通用又紧凑，Java是通用而不紧凑，ruby、Python之类的脚本语言也是如此，正则表达式（如果也算语言的话）是不通用而紧凑，Erlang也是通用而紧凑，awk却是既不通用也不紧凑，XSLT也可以归入不通用不紧凑的行列；Javascript是个另类，按理说它也是不通用不紧凑，说它不通用是因为它的主要应用范围还是局限在web开发的UI上，实际上Javascript也是门通用语言,但是很少会有人会用javascript去写批处理脚本,Javascript显然是不紧凑的，太多的边边角角甚至奇奇怪怪的东西需要你去注意，然而就是这样一门不通用不紧凑的语言现在却非常有前途，只能说时势所然。

设计微型语言：

1、选择正确的复杂度，要的是数据文件格式，还是微型语言？

2、扩展和嵌入语言

3、编写自定义语法，yacc和lex

4、慎用宏，宏的主要问题是滥用带来的奇怪、不透明的代码，以及对错误诊断的扰乱。

5、语言还是应用协议。

dennis 2010-02-22 00:46 发表评论

《Unix编程艺术》重读笔记(二)

dennis — Fri, 19 Feb 2010 11:25:00 GMT

模块性：保持清晰，保持简洁

软件设计有两种方式：一种是设计得极为简洁，没有看得到的缺陷；另一种是设计得极为复杂，有缺陷也看不出来。第一种方式的难度要大得多。

模块化代码的首要特质就是封装，API在模块间扮演双重角色，实现层面作为模块之间的滞塞点，阻止各自的内部细节被相邻模块知晓；在设计层面，正是API真正定义了整个体系。

养成在编码前为API编写一段非正式书面描述的习惯，是一个非常好的方法。

模块的最佳大小，逻辑行200-400行，物理行在400-800之间。

紧凑性就是一个设计能否装入人脑中的特性。测试软件紧凑性的一个简单方法是：一个有经验的用户通常需要用户手册吗？如果不需要，那么这个设计是紧凑的。

理解紧凑性可以从它的“反面”来理解，紧凑性不等于“薄弱”，如果一个设计构建在易于理解且利于组合的抽象概念上，则这个系统能在具有非常强大、灵活的功能的同时保持紧凑。紧凑也不等同于“容易学习”：对于某些紧凑设计而言，在掌握其精妙的内在基础概念模型之前，要理解这个设计相当困难；但一旦理解了这个概念模型，整个视角就会改变，紧凑的奥妙也就十分简单了。紧凑也不意味着“小巧”。即使一个设计良好的系统，对有经验的用户来说没什么特异之处、“一眼”就能看懂，但仍然可能包含很多部分。

评测一个API紧凑性的经验法则是：API的入口点通常在7个左右，或者按《代码大全2》的说法，7+2和7-2的范围内。

重构技术中的很多坏味道，特别是重复代码，是违反正交性的明显例子，“重构的原则性目标就是提高正交性”。

DRY原则，或者称为SPOT原则（single point of truth)——真理的单点性。重复的不仅仅是代码，还包括数据结构，数据结构模型应该最小化，提倡寻找一种数据结构，使得模型中的状态跟真实世界系统的状态能够一一对应。

要提高设计的紧凑性，有一个精妙但强大的方法，就是围绕“解决一个定义明确的问题”的强核心算法组织设计，避免臆断和捏造，将任务的核心形式化，建立明确的模型。

文本化：好协议产生好实践

文本流是非常有用的通用格式，无需专门工具就可以很容易地读写和编辑文本流，这些格式是透明的。如果担心性能问题，就在协议层面之上或之下压缩文本协议流，最终产生的设计会比二进制协议更干净，性能可能更好。使用二进制协议的唯一正当理由是：如果要处理大批量的数据，因而确实关注能否在介质上获得最大位密度，或者是非常关心将数据转化为芯片核心结构所必须的时间或指令开销。

数据文件元格式：

1、DSV风格，DElimiter-Seperated Values

使用分隔符来分隔值，例如/etc/passwd

适合场景：数据为列表，名称（首个字段）为关键字，而且记录通常很短（小于80个字符）

2、RFC 822格式

互联网电子邮件信息采用的文本格式，使用属性名+冒号+值的形式，记录属性每行存放一个，如HTTP 1.1协议。

适合场景：任何带属性的或者与电子邮件类似的信息，非常适合具有不同字段集合而字段中数据层次又扁平的记录。

3、Cookie-jar格式。简单使用跟随%%的新行符（或者有时只有一个%)作为记录分隔符，很适用于记录非结构化文本的情况。

适合场景：词以上结构没有自然顺序，而且结构不易区别的文本段，或适用于搜索关键字而不是文本上下文的文本段。

4、Record-jar格式，cookie-jar和RFC-822的结合，形如

name:dennis
age:21
%%
name:catty
age:22
%%
name:green
age:10

这样的格式。

适合场景：那些类似DSV文件，但又有可变字段数据而且可能伴随无结构文本的字段属性关系集合。

5、XML格式，适合复杂递归和嵌套数据结构的格式，并且经常可以在无需知道数据语义的情况下仅通过语法检查就能发现形式不良损坏或错误生成的数据。缺点在于无法跟传统unix工具协作。

6、Windows INI格式，形如

[DEFAULT]
account=esr

[python]
directory=/home/ers/cvs/python
developer=1

[sng]
directory=/home/esr/WWW/sng
numeric_id=1001
developer=1

[fetchmail]
numeric_id=4928492

这样的格式

适合场景：数据围绕指定的记录或部分能够自然分成“名称-属性对”两层组织结构。

Unix文本文件格式的约定：

1、如果可能，以新行符结束的每一行只存一个记录

2、如果可能，每行不超过80个字符

3、使用”＃“引入注释

4、支持反斜杠约定

5、在每行一条记录的格式中，使用冒号或连续的空白作为字段分隔符。

6、不要过分区分tab和whitespace

7、优先使用十六进制而不是八进制。

8、对于复杂的记录，使用“节（stanza)”格式，要么让记录格式和RFC 822电子邮件头类似，用冒号终止的字段名关键字作为引导字段。

9、在节格式中，支持连续行，多个逻辑行折叠成一个物理行

10、要么包含一个版本号，要么将格式设计成相互独立的的自描述字节块。

11、注意浮点数取整。

12、不要仅对文件的一部分进行压缩或者二进制编码。

应用协议元格式

1、经典的互联网应用元协议 RFC 3117《论应用协议的设计》，如SMTP、POP3、IMAP等协议

2、作为通用应用协议的HTTP，在HTTP上构建专用协议，如互联网打印协议(IPP）

3、BEEP：块可扩展交换协议，既支持C/S模式，又支持P2P模式

4、XMP-RPC、SOAP和Jabber，基于XML的协议。

透明性：来点光

美在计算科学中的地位，要比在其他任何技术中的地位都重要，因为软件是太复杂了。美是抵御复杂的终极武器。

如果没有阴暗的角落和隐藏的深度，软件系统就是透明的。透明性是一种被动品质。如果实际上能预测到程序行为的全部或大部分情况，并能建立简单的心理模型，这个程序就是透明的，因为可以看透机器究竟在干什么。

如果软件系统所包含的功能是为了帮助人们对软件建立正确的“做什么、怎样做”的心理模型而设计，这个软件系统就是可显的。

不要让调试工具仅仅成为一种事后追加或者用过就束之高阁的东西。它们是通往代码的窗口：不要只在墙上凿出粗糙的洞，要修整这些洞并装上窗。如果打算让代码一直可被维护，就始终必须让光照进去。例如fetchmail的-v选项将处理SMTP、POP的处理过程打印到标准输出，使得fetchmail行为具有可显性。

在“这个设计能行吗？”之后要提出的头几个问题就是“别人能读懂这个设计吗?这个设计优雅吗？”我们希望，此时大家已经很清楚，这些问题不是废话，优雅不是一种奢侈。在人类对软件的反映中，这些品质对于减少软件bug和提高软件长期维护性是最基本的。

要追求代码的透明性，最有效的方法是很简单，就是不要在具体操作的代码上叠放太多的抽象层。

OO语言使得抽象变得容易——也许是太容易了。OO语言鼓励“具有厚重的胶合和复杂层次”的体系。当问题领域真的很复杂，确实需要大量抽象时，这可能是好事，但如果coder到头来用复杂的办法做简单的事情——仅仅是为他们能够这样做，结果便适得其反。

所有的OO语言都显示出某种使程序员陷入过度分层陷阱的倾向。对象框架和对象浏览器并不能代替良好的设计和文档，但却常常被混为一谈。过多的层次破坏了透明性：我们很难看清这些层次，无法在头脑中理清代码到底是怎样运行的。简洁、清晰和透明原则通通被破坏了，结果代码中充满了晦涩的bug，始终存在维护问题。

胶合层中的“智能数据”却经常不代表任何程序处理的自然实体——仅仅只是胶合物而已（典型现象就是抽象类和混入(mixin)类的不断扩散）

OO抽象的另一个副作用就是程序往往丧失了优化的机会。

OO在其取得成功的领域（GUI、仿真和图形）之所以能成功，主要原因之一可能是因为在这些领域里很难弄错类型的本体问题。例如，在GUI和图形系统中，类和可操作的可见对象之间有相当自然的映射关系。

Unix风格程序设计所面临的主要挑战就是如何将分离法的优点（将问题从原始的场景中简化、归纳）同代码和设计的薄胶合、浅平透层次结构的优点相组合。

太多的OO设计就像是意大利空心粉一样，把“is-a”和“have a”的关系弄得一团糟，或者以厚胶合层为特征，在这个胶合层中，许多对象的存在似乎只不过是为了在陡峭的抽象金字塔上占个位置罢了。这些设计都不透明，它们晦涩难懂并且难以调试。

为透明性和可显性而编码：

1、程序调用层次中（不考虑递归）最大的静态深度是多少？如果大于四，就要当心。

2、代码是否具有强大、明显的不变性质（约束）？不变性质帮助人们推演代码和发现有问题的情况。

3、每个API中各个函数调用是否正交？或者是否存在太多的magic flags或者模式位？

4、是否存在一些顺手可用的关键数据结构或全局唯一的记录器，捕获系统的高层次状态？这个状态是否容易被形象化和检验，还是分布在数目众多的各个全局变量或对象中而难以找到？

5、程序的数据结构或分类和它们所代表的外部实体之间，是否存在清晰的一对一映射。

6、是否容易找到给定函数的代码部分？不仅单个函数、模块，还有整个代码，需要花多少精力才能读懂？

7、代码增加了特殊情况还是避免了特殊情况？每一个特殊情况可能对任何其他特殊情况产生影响：所有隐含的冲突都是bug滋生的温床。然而更重要的是，特殊情况使得代码更难理解。

8、代码中有多少个magic number?通过审查是否很容易查出代码中的限制（比如关键缓冲区的大小）？

隐藏细节和无法访问细节有着重要区别。不要过度保护。

无论何时碰到涉及编辑某类复杂二进制对象的设计问题时，unix传统都提倡首先考虑，是否能够编写一个能够在可编辑的文本格式和二进制格式之间来回进行无损转换的工具？这类工具可称为文本化器(textualizer).

宁愿抛弃、重建代码也不愿修补那些蹩脚的代码。

“代码是活代码、睡代码还是死代码？”活代码周围存在一个非常活跃的开发社团。睡代码之所以“睡着”，经常是因为对作者而言，维护代码的痛苦超过了代码本身的效用。死代码则是睡得太久，重新实现一段等价代码更容易。

dennis 2010-02-19 19:25 发表评论

《Unix编程艺术》重读笔记(一)

dennis — Thu, 18 Feb 2010 11:23:00 GMT

Unix哲学是自下而上，而不是自上而下的，注重实效，立足于丰富的经验，你不会在正规方法学和标准中找到它。

Unix管道的发明人Doug McIlroy曾经说过：

1、让每个程序就做好一件事，如果有新任务就重新开始，不要往新程序中加入功能而搞的复杂。

2、假定每个程序的输出都会成为另一个程序的输入，哪怕那个程序是未知的。输出中不要有无关的信息干扰，避免使用严格的分栏格式和二进制格式输入。不要坚持使用交互式输入。

3、尽可能早将设计和编译的软件投入试用，哪怕是操作系统也不例外，理想情况下应该是几星期内，对抽劣的代码别犹豫，扔掉重写。

4、优先使用工具，而非拙劣的帮助来减轻编程任务的负担，工欲善其事，必先利其器。

Rob Pike在《Notes on C programming》中提到：

原则1：你无法断行程序会在什么地方耗费运行时间。瓶颈经常出现在想不到的地方，所以别急于胡乱找个地方改代码，除非你已经证实那儿就是瓶颈所在。

原则2：估量。在你没对代码进行估量，特别是没找到最耗时的那部分之前，别去优化速度。

原则3：花哨的算法，在n很小的适合通常很慢，而n通常很小。花哨算法的常数复杂度很大，除非你确定n一直很大,否则不要用花哨算法（即使n很大，也要优先考虑原则2）。

原则4：花哨的算法比简单的算法更容易出bug ,更难实现。尽量使用简单的算法配合简单的数据结构。

原则5：数据压倒一切。如果已经选择了正确的数据结构并且把一切组织得井井有条，正确的算法也就不言自明，编程的核心是数据结构，而不是算法。

原则6：没有原则6.

Ken Thompson对原则4做了强调：

拿不准就穷举。

Unix哲学的17条原则：

1、模块原则：简洁的接口拼合简单的部件。

2、清晰原则：清晰胜于机巧。

3、组合原则：设计时考虑拼接组合。

4、分离原则：策略同机制分离，接口同引擎分离。

5、简洁原则：设计要简洁，复杂度能低则低。

6、吝啬原则：除非却无他法，不要编写庞大的程序。

7、透明性原则：设计要可见，以便审查和调试。

8、健壮原则：健壮源于透明与简洁。

9、表示原则：把知识叠入数据，以求逻辑质朴而健壮。

10、通俗原则：接口设计避免标新立异。

11、缄默原则：如果一个程序没什么好说的，就沉默。

12、补救原则：出现异常时，马上退出，并给出足够错误信息。

13、经济原则：宁花机器一分，不花程序员一秒。

14、生成原则：避免手工hack，尽量编写程序去生成程序。

15、优化原则：雕琢前先要有原型，跑之前先学会走。

16、多样原则：绝不相信所谓“不二法门”的断言。

17、扩展原则：设计着眼未来，未来总是比预想来得快。

Unix哲学之一言以蔽之：KISS

Keep it simple,stupid!

应用unix哲学：

1、只要可行，一切都应该做成与来源和目标无关的过滤器。

2、数据流应尽可能的文本化（这样可以用标准工具来查看和过滤）。

3、数据库部署和应用协议应尽可能文本化（让人阅读和编辑）。

4、复杂的前端（用户界面）和后端应该泾渭分明。

5、如果可能，用c编写前，先用解释性语言搭建原型。

6、当且仅当只用一门编程语言会提高程序复杂度时，混用语言编程才比单一语言编程来得好。

7、宽收严发（对接收的东西要包容，对输出的东西要严格）

8、过滤时，不需要丢弃的消息绝不丢。

9、小就是美。在确保完成任务的基础上，程序功能尽可能的少。

最后强调的是态度：

要良好地运用unix哲学，你就应该不断地追求卓越，你必须相信，程序设计是一门技艺，值得你付出所有的智慧、创造力和激情。否则，你的视线就不会超越那些简单、老套的设计和实现；你就会在应该思考的时候急急忙忙跑去编程。你就会在该无情删繁就简的时候反而把问题复杂化——然后你还会反过来奇怪你的代码怎么会那么臃肿，那么难以调试。

要良好地运用unix哲学，你应该珍惜你的时间绝不浪费。一旦某人已经解决了某个问题，就直接拿来利用，不要让骄傲或偏见拽住你又去重做一遍。永远不要蛮干；要多用巧劲，省下力气在需要的时候用，好钢用到刀刃上。善用工具，尽可能将一切自动化。

软件设计和实现是一门充满快乐的艺术，一种高水平的游戏。如果这种态度对你来说听起来有些荒谬，或者令你隐约感到有些困窘，那么请停下来，想一想，问问自己是不是已经把什么给遗忘了。如果只是为了赚钱或者打发时间，你为什么要搞软件设计，而不是别的什么呢？你肯定曾经也认为软件设计值得你付出激情……

要良好地运用unix哲学，你需要具备（或者找回）这种态度。你需要用心。你需要去游戏。你需要乐于探索。

操作系统的风格元素：

1、什么是操作系统的统一性理念

2、多任务能力

3、协作进程（IPC）

4、内部边界

5、文件属性和记录结构

6、二进制文件格式

7、首选用户界面风格

8、目标受众

9、开发的门坎

dennis 2010-02-18 19:23 发表评论

不是抽象的漏洞，而是本质复杂性

dennis — Sun, 10 Jan 2010 12:25:00 GMT

    《Joel on software》谈到所谓抽象漏洞，简单来说就是抽象能解决90%的一般情况，而其他10%的情况你仍然需要跟抽象层面下的细节打交道，也就是抽象本身只能减少你的工作时间，而无法减少你的学习时间。道理简单，举几个例子。
    以SQL语言为例，SQL是所谓说明性的语言，你所写的语句只是一条what，而how是如何做的无需关心，但是真的无需关心吗？事实上是不行，低效的SQL语句对数据库的性能损害非常大，作为程序员你需要知道SQL这个抽象层次下的部分内容，知道数据库是怎么执行这些语句，知道如何去避免一些最差实践。再比如分布式调用希望做到能跟本地调用一样的透明，但实际上还是不行的，网络的不确定性让RPC调用根本无法做到的类似本地调用那样的透明性。隐藏在RPC这个抽象层次下的网络通信细节，你不能不去care。抽象能帮你解决大多数情况，提高你的工作效率，但是剩下的一公里问题，仍然需要你花费更多时间和精力去了解并解决。这事实上也是一个优秀程序员跟普通程序的差别之一，学习了java编程，知道了collection集合框架，不代表你无需再去学习数据结构和算法。
    Joel将这个现象称为漏洞抽象。事实上，我并不认为这是抽象本身的漏洞，这反而是软件的本质复杂性在作怪，抽象只能去化简偶然复杂性，例如函数、类、模块化等手段去组织代码，而本质的复杂性是无法避免的。举个不是那么恰当的例子，例如我们有这么个方法，传进一个参数list，我们要遍历list做一些事情，（我知道用迭代器才是正途，先允许我犯这么个错误），你可能这么写：

    public void doSomething(List<String> list){
        for(int i=0;i<list.size();i++){
            String str=list.get(i);
            //do something
        }
    }

   这样的代码我估计在1.5有for语句增强之前不少人都写过，这样的代码有什么问题呢？考虑下list是ArrayList和LinkedList这两种情况，List是链表的抽象，但是链表的实现形式却是可以用数组或者引用链接，链表的实现形式不同，List.get(index)这个方法的效率会很成问题。我们都知道ArrayList适宜于随机访问，而LinkedList方便插入添加移除，在这个doSomething方法中，显然随机访问的诉求大于添加移除。在通常情况下，这样写都不会成为问题，但是如果这个doSomething方法被经常调用，并且list是一个LinkedList的情况下，这个方法就很可能成为性能瓶颈。我们寄希望于List这个接口可以让我们无需关心list的具体实现，然而现实是你仍然需要知道各种实现的区别和原理，这就是所谓漏洞抽象。这并非抽象的无力，你肯定不会反对“针对接口编程”这条原则，而是抽象本身解决不了本质复杂性，这里的本质复杂性就是链表的实现方法，随机访问与添加移除的平衡问题。在我们无法找到更好的链表实现方法来平衡随机访问与添加移除之前，这个本质复杂性就不是抽象能够解决的。
    同样的现象出现在String、StringBuffer、StringBuilder的使用上，字符串的实现方法你仍然需要知道，这是绕不过去的本质复杂性。这里谈到的本质复杂性根本上也是现实世界的本质复杂性的反映，扯远些就更虚了。就现实的工作情况来看，不知道其他人有没有这样的经验，就是在自以为解决某个难题的时候，最后却发现难题以另一个面目出现，问题本身没有得到解决，只是以更好的方式被掩盖了。
   无论是过程式、OO、函数式编程，解决的问题都是为了更好的抽象，抽象是个好东西，但是抽象无法解决那些本质性的问题，因此《人月神话》断言没有银弹，我们仍然需要跟狼人作战。

dennis 2010-01-10 20:25 发表评论

逻辑学应该从小学教起

dennis — Sat, 12 Dec 2009 08:35:00 GMT

最近读数理逻辑方面的资料，感慨自己没有早点接触逻辑学，如果在小学初中阶段就能有逻辑学的系统训练，我想我对数学的理解会完全不一样，对定理证明的思路也将大大开拓。中学时代对数学充满热情，基本上老师讲的都满足不了我，我的学习远远在课堂前面，初中的时候我已经接触了微积分、概率论、立体几何之类，教材是从我舅舅用过的教材垃圾堆里淘出来的，那时候我外婆准备卖了那堆书，就叫我去看看有没有想要的，印象中从那里掏出了不少好东西，武侠小说、马克思恩格斯全集、毛选、数学语文教材之流，在老家那个阅读资料极度缺少的地方，这些书成了我整个初中的精神食粮。上了高中后，家也搬到县城，离书城近了，并且学校有图书馆，更是如鱼得水。扯的太远，回到题目，以数学定理的证明为例，我们熟知的直接证明、反证法、数学归纳法、间接证明、存在性证明、唯一性证明其实背后都有牢固的逻辑定律在支撑，直接证明其实就是蕴含 p-> q，而反证法的原理是¬¬p ↔ p，间接证明则是原命题与逆否命题等价 p-> q ↔ ¬q -> ¬p等等。如果在教授数学的同时，教授给学生背后的逻辑原理，那么将极大地开阔学生的视野并且让数学证明变的有趣。数理逻辑不仅仅对数学学习有益，对软件开发同样有帮助，例如以谓词和量词来精确地描述和分析系统规格，推理逻辑的使用也能启发你的设计思路，帮你找到一个复杂的设计的等价物。此外，你能更快地比别人做出某些逻辑难题，这也挺有趣。

dennis 2009-12-12 16:35 发表评论

amb解决排列组合问题

dennis — Mon, 19 Oct 2009 03:37:00 GMT

看到这么一个题目：
{3,2,2,6,7,8}排序输出,7不在第二位,68不在一起。

这样的题目似乎避免不了遍历，关键还在于过滤条件的安排，怎么让过滤的范围尽量地小。通常的做法是循环遍历，对于类似Prolog这样的语言来说，由于内置了推理引擎，可以简单地描述问题，让引擎来帮你做递归遍历，解决这类问题是非常简单的。Prolog好久没写，以Ruby的amb操作符为例来解决这道题目：

#结果为hash，去重
$hash={}
amb=Amb.new
array=[3,2,2,6,7,8]
class << array
alias remove delete
def delete(*nums)
   result=dup
   nums.each do |n|
    result.delete_at(result.index(n)) if result.index(n)
   end
   result
end
end
#从集合选元素
one=amb.choose(*array)
two=amb.choose(*(array.delete(one)))
three=amb.choose(*(array.delete(one,two)))
four=amb.choose(*(array.delete(one,two,three)))
five=amb.choose(*(array.delete(one,two,three,four)))
six=amb.choose(*(array.delete(one,two,three,four,five)))

#条件1：第二个位置不能是7
amb.require(two!=7)
#条件2：6跟8不能一起出现
def six_eight_not_join(a,b)
   "#{a}#{b}"!="68"&&"#{a}#{b}"!="86"
end
amb.require(six_eight_not_join(one,two))
amb.require(six_eight_not_join(two,three))
amb.require(six_eight_not_join(three,four))
amb.require(six_eight_not_join(four,five))
amb.require(six_eight_not_join(five,six))

#条件3：不重复,利用全局hash判断
def distinct?(one,two,three,four,five,six)
  if $hash["#{one},#{two},#{three},#{four},#{five},#{six}"].nil?
     $hash["#{one},#{two},#{three},#{four},#{five},#{six}"]=1 #记录
     true
  else
     false
  end
end
amb.require(distinct?(one,two,three,four,five,six))
puts "#{one},#{two},#{three},#{four},#{five},#{six}"
amb.failure

三个条件的满足通过amb.require来设置，这里安排的只是一种顺序，可以根据实际测试结果来安排这些条件的顺序以最大程度地提高效率。代码注释很清楚了，我就不多嘴了。Ruby amb的实现可以看这里。什么是amb可以看这个。

dennis 2009-10-19 11:37 发表评论

os的进程调度（读书笔记）

dennis — Sun, 28 Jun 2009 05:28:00 GMT

    在多进程、多线程并发的环境里，从概念上看，有多个进程或者多个线程在同时执行，具体到单个CPU级别，实际上任何时刻只能有一个进程或者线程处于执行状态；因此OS需要决定哪个进程执行，哪些进程等待，也就是进程的调度。
一、调度的目标
1、首先要区分程序使用CPU的三种模式：IO密集型、计算密集型和平衡型。对于IO密集型程序来说，响应时间非常重要；对于CPU密集型来说，CPU的周转时间就比较重要；对于平衡型程序来说，响应和周转之间的平衡是最重要的。
2、CPU的调度就是要达到极小化平均响应时间、极大化系统吞吐率、保持系统各个功能部件均处于繁忙状态和提供某种公平的机制。
3、对于实时系统来说，调度的目标就是要达到截止时间前完成所应该完成的任务和提供性能的可预测性。

二、调度算法

1、FCFS（First come first serve)，或者称为FIFO算法，先来先处理。这个算法的优点是简单，实现容易，并且似乎公平；缺点在于短的任务有可能变的非常慢，因为其前面的任务占用很长时间，造成了平均响应时间非常慢。

2、时间片轮询算法，这是对FIFO算法的改进，目的是改善短程序（运行时间短）的响应时间，其方法就是周期性地进行进程切换。这个算法的关键点在于时间片的选择，时间片过大，那么轮转就越接近FIFO，如果太小，进程切换的开销大于执行程序的开销，从而降低了系统效率。因此选择合适的时间片就非常重要。选择时间片的两个需要考虑的因素：一次进程切换所使用的系统消耗以及我们能接受的整个系统消耗、系统运行的进程数。
    时间片轮询看上起非常公平，并且响应时间非常好，然而时间片轮转并不能保证系统的响应时间总是比FIFO短，这很大程度上取决于时间片大小的选择，以及这个大小与进程运行时间的相互关系。

3、STCF算法（Short time to complete first)，顾名思义就是短任务优先算法。这种算法的核心就是所有的程序都有一个优先级，短任务的优先级比长任务的高，而OS总是安排优先级高的进程运行。
    STCF又分为两类：非抢占式和抢占式。非抢占式STCF就是让已经在CPU上运行的程序执行到结束或者阻塞，然后在所有的就绪进程中选择执行时间最短的来执行；而抢占式STCF就不是这样，在每进来一个新的进程时，就对所有进程（包括正在CPU上执行的进程）进行检查，谁的执行时间短，就运行谁。

    STCF总是能提供最优的响应时间，然而它也有缺点，第一可能造成长任务的程序无法得到CPU时间而饥饿，因为OS总是优先执行短任务；其次，关键问题在于我们怎么知道程序的运行时间，怎么预测某个进程需要的执行时间？通常有两个办法：使用启发式方法估算（例如根据程序大小估算），或者将程序执行一遍后记录其所用的CPU时间，在以后的执行过程中就可以根据这个测量数据来进行STCF调度。

4、优先级调度，STCF遇到的问题是长任务的程序可能饥饿，那么优先级调度算法可以通过给长任务的进程更高的优先级来解决这个问题；优先级调度遇到的问题可能是短任务的进程饥饿，这个可以通过动态调整优先级来解决。实际上动态调整优先级（称为权值）+时间片轮询的策略正是linux的进程调度策略之一的 SCHED_OTHER分时调度策略,它的调度过程如下：

（1）创建任务指定采用分时调度策略，并指定优先级nice值(-20~19)。

（2）将根据每个任务的nice值确定在cpu上的执行时间(counter)。

（3）如果没有等待资源，则将该任务加入到就绪队列中。

（4）调度程序遍历就绪队列中的任务，通过对每个任务动态优先级的计算(counter+20-nice)结果，选择计算结果最大的一个去运行，当这个时间片用完后(counter减至0)或者主动放弃cpu时，该任务将被放在就绪队列末尾(时间片用完)或等待队列(因等待资源而放弃cpu)中。

（5）此时调度程序重复上面计算过程，转到第4步。

（6）当调度程序发现所有就绪任务计算所得的权值都为不大于0时，重复第2步。

linux还有两个实时进程的调度策略：FIFO和RR,实时进程会立即抢占非实时进程。

5、显然，没有什么调度算法是毫无缺点的，因此现代OS通常都会采用混合调度算法。例如将不同的进程分为几个大类，每个大类有不同的优先级，不同大类的进程的调度取决于大类的优先级，同一个大类的进程采用时间片轮询来保证公平性。

6、其他调度算法，保证调度算法保证每个进程享用的CPU时间完全一样；彩票调度算法是一种概率调度算法，通过给进程“发彩票”的多少，来赋予不同进程不同的调用时间，彩票调度算法的优点是非常灵活，如果你给短任务发更多“彩票”，那么就类似STCF调度，如果给每个进程一样多的“彩票”，那么就类似保证调度；用户公平调度算法，是按照每个用户，而不是按照每个进程来进行公平分配CPU时间，这是为了防止贪婪用户启用了过多进程导致系统效率降低甚至停顿。

7、实时系统的调度算法，实时系统需要考虑每个具体任务的响应时间必须符合要求，在截止时间前完成。
（1）EDF调度算法，就是最早截止任务优先（Earliest deadline first)算法，也就是让最早截止的任务先做。当新的任务过来时，如果它的截止时间更靠前，那么就让新任务抢占正在执行的任务。EDF算法其实是贪心算法的一种体现。如果一组任务可以被调度（也就是所有任务的截止时间在理论上都可以得到满足），那么EDF可以满足。如果一批任务不能全部满足（全部在各自的截止时间前完成），那EDF满足的任务数最多，这就是它最优的体现。EDF其实就是抢占式的STCF，只不过将程序的执行时间换成了截止时间。EDF的缺点在于需要对每个任务的截止时间做计算并动态调整优先级，并且抢占任务也需要消耗系统资源。因此它的实际效果比理论效果差一点。

（2）RMS调度算法，EDF是动态调度算法，而RMS（rate monotonic scheduling)算法是一种静态最优算法；该算法在进行调度前先计算出所有任务的优先级，然后按照计算出来的优先级进行调度，任务执行中间既不接收新任务，也不进行优先级调整或者CPU抢占。因此它的优点是系统消耗小，缺点就是不灵活了。对于RMS算法，关键点在于判断一个任务组是否能被调度，这里有一个定律，如果一个系统的所有任务的CPU利用率都低于ln2，那么这些任务的截止时间均可以得到满足，ln2约等于0.693147，也就是此时系统还剩下有30%的CPU时间。这个证明是Liu和Kayland在1973年给出的。

三、优先级反转
1、什么是优先级反转？
    优先级反转是指一个低优先级的任务持有一个被高优先级任务所需要的共享资源。高优先任务由于因资源缺乏而处于受阻状态，一直等到低优先级任务释放资源为止。而低优先级获得的CPU时间少，如果此时有优先级处于两者之间的任务，并且不需要那个共享资源，则该中优先级的任务反而超过这两个任务而获得CPU时间。如果高优先级等待资源时不是阻塞等待，而是忙循环，则可能永远无法获得资源，因为此时低优先级进程无法与高优先级进程争夺CPU时间，从而无法执行，进而无法释放资源，造成的后果就是高优先级任务无法获得资源而继续推进。

2、解决方案：
（1）设置优先级上限，给临界区一个高优先级，进入临界区的进程都将获得这个高优先级，如果其他试图进入临界区的进程的优先级都低于这个高优先级，那么优先级反转就不会发生。

（2）优先级继承，当一个高优先级进程等待一个低优先级进程持有的资源时，低优先级进程将暂时获得高优先级进程的优先级别，在释放共享资源后，低优先级进程回到原来的优先级别。嵌入式系统VxWorks就是采用这种策略。
    这里还有一个八卦，1997年的美国的火星探测器（使用的就是vxworks)就遇到一个优先级反转问题引起的故障。简单说下，火星探测器有一个信息总线，有一个高优先级的总线任务负责总线数据的存取，访问总线都需要通过一个互斥锁（共享资源出现了）；还有一个低优先级的，运行不是很频繁的气象搜集任务，它需要对总线写数据，也就同样需要访问互斥锁；最后还有一个中优先级的通信任务，它的运行时间比较长。平常这个系统运行毫无问题，但是有一天，在气象任务获得互斥锁往总线写数据的时候，一个中断发生导致通信任务被调度就绪，通信任务抢占了低优先级的气象任务，而无巧不成书的是，此时高优先级的总线任务正在等待气象任务写完数据归还互斥锁，但是由于通信任务抢占了CPU并且运行时间比较长，导致气象任务得不到CPU时间也无法释放互斥锁，本来是高优先级的总线任务也无法执行，总线任务无法及时执行的后果被探路者认为是一个严重错误，最后就是整个系统被重启。Vxworks允许优先级继承，然而遗憾的工程师们将这个选项关闭了。

（3）第三种方法就是使用中断禁止，通过禁止中断来保护临界区，采用此种策略的系统只有两种优先级：可抢占优先级和中断禁止优先级。前者为一般进程运行时的优先级，后者为运行于临界区的优先级。火星探路者正是由于在临界区中运行的气象任务被中断发生的通信任务所抢占才导致故障，如果有临界区的禁止中断保护，此一问题也不会发生。

dennis 2009-06-28 13:28 发表评论

sicp 5.1节习题尝试解答

dennis — Wed, 10 Jun 2009 16:47:00 GMT

5.1 图就不画在机器上了，麻烦

5.2 用寄存器语言描述5.1题中的阶乘机器，加上了读取和打印,这里的解答全部在实际的寄存机器中验证过，但是仍然按照该节的表示法表示。

(controller
fac-loop
   (assign n (op read))
   (assign product (const 1))
   (assign counter (const 1))
iter-loop
   (test (op >) (reg counter) (reg n))
   (branch (label iter-done))
   (assign product (op *) (reg product) (reg counter))
   (assign counter (op +) (reg counter) (const 1))
   (goto (label iter-loop))
iter-done
   (perform (op print) (reg product))
   (goto (label fac-loop)))

5.3 牛顿法求平方根，将这个过程转化为寄存器语言，第一个版本，假设good-enough?和improve都是基本过程，

;version1
(controller
   sqrt-loop
    (test (op good-enough?) (reg guess))
    (branch (label sqrt-done))
    (assign guess (op improve) (reg guess))
    (goto (label good-enough))
   sqrt-done)

第二个版本，展开good-enough?过程，

;version2
(controller
   good-enough
    (assign t (op square) (reg guess))
    (assign t (op -) (reg t) (reg x))
    (assign t (op abs) (reg t))
    (test (op <) (reg t) (const 0.001))
    (branch (label sqrt-done))
    (assign guess (op improve) (reg guess))
    (goto (label good-enough))
   sqrt-done)

最后，展开improve过程，

;version3
(controller
sqrt-init
   (assign guess (const 1.0))
   (assign x (op read))
good-enough
    ;good-enough
   (assign t (op square) (reg guess))
   (assign t (op -) (reg t) (reg x))
   (assign t (op abs) (reg t))
   (test (op <) (reg t) (const 0.001))
   (branch (label sqrt-done))
    ;improve
   (assign t (op /) (reg x) (reg guess))
   (assign t (op +) (reg guess) (reg t))
   (assign guess (op /) (reg t) (const 2.0))
   (goto (label good-enough))
sqrt-done)

在start之后，从寄存器guess中得到最后结果。

5.4
a)第一个是一个指数计算过程，用到了递归，因此需要引入continue寄存器来保存和恢复堆栈，实现与阶乘相似，如下

(controller
    (assign continue (label expt-done))
    expt-loop
      (test (op =) (reg n) (const 0))
      (branch (label expt-base-case))
      ;;保存continue
      (save continue)
      (assign n (op -) (reg n) (const 1))
      (assign continue (label after-expt))
      (goto (label expt-loop))
    after-expt
      ;;恢复continue
      (restore continue)
      (assign val (op *) (reg b) (reg val))
      (goto (reg continue))
    expt-base-case
      (assign val (const 1))
      (goto (reg continue))
    expt-done
      (perform (op display) (reg val)))

b) 迭代型的递归计算过程，尾递归调用，因此不需要continue寄存器来保存和恢复堆栈，这道习题就是希望能分辨非尾递归和尾递归带来的寄存机器语言的区别

(controller
    (assign product (const 1))
    (assign n (op read))
    (assign b (op read))
    (assign counter (reg n))
   expt-iter-loop
     (test (op =) (reg counter) (const 0))
     (branch (label expt-done))
     (assign counter (op -) (reg counter) (const 1))
     (assign product (op *) (reg b) (reg product))
     (goto (label expt-iter-loop))
   expt-done
      (perform (op display) (reg product)))

5.5 手工模拟就算了，5.2节就可以机器模拟了

5.6 是有一个多余的save和一个多余的restore操作，请看注释：

(
   (assign continue (label fib-done))
  fib-loop
   (test (op <) (reg n) (const 2))
   (branch (label immediate-answer))
   ;;compute fib(n-1)
   (save continue)
   (assign continue (label after-fib-1))
   (save n)
   (assign n (op -) (reg n) (const 1))
   (goto (label fib-loop))
  after-fib-1
   ;;compute fib(n-2)
   (restore n)
   ;这里多余，(restore continue)
   (assign n (op -) (reg n) (const 2))
   ;这里多余，(save continue)
   (assign continue (label after-fib-2))
   (save val) ;;save fib(n-1)
   (goto (label fib-loop))
  after-fib-2
   (assign n (reg val))
   (restore val)
   (restore continue)
   (assign val (op +) (reg val) (reg n))
   (goto (reg continue))
immediate-answer
   (assign val (reg n))
   (goto (reg continue))

fib-done)

dennis 2009-06-11 00:47 发表评论

关于网络的错误假设

dennis — Sat, 02 May 2009 05:02:00 GMT

每个第一次构建分布式系统的人都可能会做出8个错误的对网络的假设：

1.	The network is reliable
2.	Latency is zero
3.	Bandwidth is infinite
4.	The network is secure
5.	Topology doesn't change
6.	There is one administrator
7.	Transport cost is zero
8.	The network is homogeneous

翻译过来就是：
1、网络是稳定可靠的
2、没有延迟
3、带宽无限
4、网络是安全的
5、网络拓扑不会改变
6、只有一个管理员
7、传输成本为0
8、网络是均匀的，现实是各种网络环境都有。

更多错误假设：
1、网络IO跟磁盘IO一样
    网络IO比之磁盘IO更不可预测、不可靠和不可控，网络IO包括了软硬件两方面的限制。
2、你与对端能够同步
你无法假设对端是否关闭、接收到数据，这些通常需要你在应用协议里同步。
3、所有的错误都可以被检测到。
    很多错误例如对端关闭引起的读阻塞都需要应用层来处理。

4、资源无限可用。
5、应用可以无限等待一个远程服务
    任何大规模的应用都需要慎重设计超时、过期策略

6、远程服务总能响应及时。
7、只有单点失败
8、只有一个资源分配器
9、只有一个时间，也就是全局时间的问题。

dennis 2009-05-02 13:02 发表评论

scheme中文编程

dennis — Fri, 20 Mar 2009 15:27:00 GMT

摘要: 受javaeye上的《Ruby中文编程》启发，帖子中有人提到如果if这样的关键字都可以定义成中文，那就是真正的中文编程。那时我就想到，这个其实要在scheme中实现是多么简单，将sicp书中的解释器稍微修改下就可以了，只要修改解析的部分即可。解释器的完整代码放后面，我们先看看有趣的例子： Code highlighting produced by A... 阅读全文

dennis 2009-03-20 23:27 发表评论

sicp 4.4.1小节习题

dennis — Sat, 22 Nov 2008 05:27:00 GMT

摘要: 本节开始进入第4章最后一部分——逻辑程序设计。scheme将实现一种查询语言，非常类似prolog。由于解释器的实现在后面，还未读到，前面的习题我都将用prolog做测试，当然也给出scheme版本的解答，待以后测试。首先给出依照书中所述写出的prolog事实库： Code highlighting prod... 阅读全文

dennis 2008-11-22 13:27 发表评论

sicp 4.3.3小节习题

dennis — Fri, 21 Nov 2008 02:26:00 GMT

本节实现了amb求值器，题目都是扩展这个求值器，引入一些特殊的过程。我的尝试解答从4.51开始
习题4.51，要求实现permanent-set!，这个过程的副作用在遇到失败时不撤销，实现如下：

;扩充analyze
((permanent-assignment? exp)
         (analyze-permanent-assignment exp))

;实现

(define (permanent-assignment? exp)
  (tagged-list? exp 'permanent-set!))
(define (analyze-permanent-assignment exp)
   (let ((var (assignment-variable exp))
        (vproc (analyze (assignment-value exp))))
      (lambda(env succeed fail)
        (vproc env
               (lambda(val fail2)
                      (set-variable-value! var val env)
                      (succeed 'ok fail2))
               fail))))

习题4.52，实现if-fail的特殊形式，在第一个表达式如果求值成功，就返回该表达式的值，否则返回第二个表达式的值，实现如下：

;扩充analyze
((if-fail? exp)
         (analyze-if-fail exp))
;实现
(define (if-fail? exp)
  (tagged-list? exp 'if-fail))
(define (analyze-if-fail exp)
   (let ((pproc (analyze (if-predicate exp)))
        (cproc (analyze (if-consequent exp))))
     (lambda(env succeed fail)
        (pproc env (lambda(pred-value fail2)
                     (succeed pred-value fail2))
               (lambda() (cproc env succeed fail))))))

pproc如果执行成功，就返回结果pred-value，否则就执行fail过程(lambda() (cproc env succeed fail))，测试略。

习题4.53，根据题意可知这个过程返回结果应该是(prime-sum-pair '(1 3 5 8) '(20 35 110))的所有结果，执行也是如此：

;;; AMB-Eval value:
((8 35) (3 110) (3 20))

习题4.54，将require实现为特殊形式：

;扩充analyze
((require? exp)
         (analyze-require exp))

;实现
(define (require? exp)
  (tagged-list? exp 'require))
(define (require-predicate exp)
  (cadr exp))
(define (analyze-require exp)
  (let ((pproc (analyze (require-predicate exp))))
    (lambda (env succeed fail)
      (pproc env (lambda(pred-value fail2)
                   (if (not pred-value)
                       (fail2)
                       (succeed 'ok fail2)))
             fail))))

dennis 2008-11-21 10:26 发表评论

使用Ruby amb解决说谎者谜题

dennis — Sat, 15 Nov 2008 10:50:00 GMT

    说谎者谜题是sicp4.3.2小节的一道题目，题目本身不难：
五个女生参加一个考试，她们的家长对考试结果过分关注。为此她们约定，在给家里写信谈到考试的时候，每个姑娘都要写一句真话和一句假话。下面是从她们的信里摘抄出来的句子：
Betty : kitty考第二，我只考了第三
Ethel : 你们应该很高兴听到我考了第一，joan第二
joan :   我考第三，可怜的Ethel垫底
kitty: 我第二，marry只考了第四
marry: 我是第四，Betty的成绩最高。
这五个姑娘的实际排名是什么？

    Ruby本来就有call/cc，因此也可以实现amb操作符，网上已经有一个实现了：

class Amb
  class ExhaustedError < RuntimeError; end
  def initialize
    @fail = proc { fail ExhaustedError, "amb tree exhausted" }
  end
  def choose(*choices)
    prev_fail = @fail
    callcc { |sk|
      choices.each { |choice|
        callcc { |fk|
          @fail = proc {
            @fail = prev_fail
            fk.call(:fail)
          }
          if choice.respond_to? :call
            sk.call(choice.call)
          else
            sk.call(choice)
          end
        }
      }
      @fail.call
    }
  end
  def failure
    choose
  end

  def assert(cond)
    failure unless cond
  end
  alias :require :assert
end

这一段代码与scheme宏实现amb是完全相同的：

(define amb-fail '*)

(define initialize-amb-fail
  (lambda ()
    (set! amb-fail
      (lambda ()
        (error "amb tree exhausted")))))

(initialize-amb-fail)
(define call/cc call-with-current-continuation)
(define-syntax amb
  (syntax-rules ()
    ((amb alt )
     (let ((prev-amb-fail amb-fail))
       (call/cc
        (lambda (sk)

          (call/cc
           (lambda (fk)
             (set! amb-fail
                   (lambda ()
                     (set! amb-fail prev-amb-fail)
                     (fk 'fail)))
             (sk alt)))

             (prev-amb-fail)))))))

回到谜题，从题意可知每个姑娘的两句话的异或结果为true，并且姑娘的排名肯定不会相同，因此定义两个辅助过程：

require 'amb'
def distinct?(items)
items.uniq==items
end
def xor(exp1,exp2)
(exp1 or exp2) and !(exp1 and exp2)
end

剩下的完全就是将题目翻译成代码即可了，没有多少可以解释的东西：

amb=Amb.new
betty=amb.choose(*[1,2,3,4,5])
ethel=amb.choose(*[1,2,3,4,5])
joan=amb.choose(*[1,2,3,4,5])
kitty=amb.choose(*[1,2,3,4,5])
marry=amb.choose(*[1,2,3,4,5])

amb.require(xor(kitty==2,betty==3))
amb.require(xor(ethel==1,joan==2))
amb.require(xor(joan==3,ethel==5))
amb.require(xor(kitty==2,marry==4))
amb.require(xor(marry==4,betty==1))
amb.require(distinct?([betty,ethel,joan,kitty,marry]))
puts "betty:#{betty} ethel:#{ethel} joan:#{joan} kitty:#{kitty} marry:#{marry}"

    答案就是：
    betty:3 ethel:5 joan:2 kitty:1 marry:4

    最后给出一个Prolog的解答：

notmember(A,[]).
notmember(A,[B|L]):-
  A\==B,
  notmember(A,L).
distinct([A,B,C,D,E]):-
   notmember(A,[B,C,D,E]),
   notmember(B,[A,C,D,E]),
   notmember(C,[A,B,D,E]),
   notmember(D,[A,B,C,E]),
   notmember(E,[A,B,C,D]).
xor(Exp1,Exp2):-
   (Exp1;Exp2),\+ (Exp1,Exp2).
solve(Betty,Ethel,Joan,Kitty,Marry):-
   X=[1,2,3,4,5],
   member(Betty,X),
   member(Ethel,X),
   member(Joan,X),
   member(Kitty,X),
   member(Marry,X),
   distinct([Betty,Ethel,Joan,Kitty,Marry]),
   xor(Kitty=:=2,Betty=:=3),
   xor(Ethel=:=1,Joan=:=2),
   xor(Joan=:=3,Ethel=:=5),
   xor(Kitty=:=2,Marry=:=4),
   xor(Marry=:=4,Betty=:=1).

dennis 2008-11-15 18:50 发表评论

sicp 4.3.2部分习题

dennis — Fri, 14 Nov 2008 16:02:00 GMT

4.38，谜题就有翻译错误，问题更是错的离谱。原题是这样的：
Baker, Cooper, Fletcher, Miller, and Smith live on different floors of an apartment house
that contains only five floors. Baker does not live on the top floor. Cooper does not live on
the bottom floor. Fletcher does not live on either the top or the bottom floor. Miller lives on
a higher floor than does Cooper. Smith does not live on a floor adjacent to Fletcher's.
Fletcher does not live on a floor adjacent to Cooper's. Where does everyone live?

其中说Miller住的比Cooper高，却翻译成了Miller住的比Cooper高一层，如果按照这个翻译来谜题是没有答案的。
回到4.38，题目是这样的：
Modify the multiple-dwelling procedure to omit the requirement that Smith and Fletcher do
not live on adjacent floors. How many solutions are there to this modified puzzle?

翻译却成了增加Smith和Fletcher不住在相邻层这个条件，谜题本来就是如此，何来的增加？错将omit翻译成了“增加”。
这道题很简单咯，将

(require (not (= (abs (- smith fletcher)) 1)))

注释掉即可，答案增加到5个：

> (multiple-dwelling)
((baker 1) (cooper 2) (fletcher 4) (miller 3) (smith 5))
> (amb)
((baker 1) (cooper 2) (fletcher 4) (miller 5) (smith 3))
>  (amb)
((baker 1) (cooper 4) (fletcher 2) (miller 5) (smith 3))
>  (amb)
((baker 3) (cooper 2) (fletcher 4) (miller 5) (smith 1))
>  (amb)
((baker 3) (cooper 4) (fletcher 2) (miller 5) (smith 1))

4.39，约束条件的顺序肯定是有影响的，能缩小搜索范围的强约束条件排在前面，弱约束条件排在后面，可以减少整体的判断次数。在DrScheme中，可以启用profile来分析顺序带来的影响，打开language->R5RS->Show Details，选择Debugging and Profiling 即可。运行scheme程序，然后在View->Show Profile中查看具体分析结果,在该视图中将详细列出各个函数调用的时间和次数。
在没有调整顺序前：
Msec      Calls      Function
40            1               multiple-dwelling
0              1716         require
4              2524          distinct?

说明multiple-dwelling调用了一次，花费了40毫秒，而require和distinct?函数分别被调用了1716次和2524次。
然后我将
(require
     (distinct? (list baker cooper fletcher miller smith)))

这个我认为弱约束条件放到了最后，测试的结果并不让人满意：
Msec      Calls      Function
44            1               multiple-dwelling
4              6035         require
0              129          distinct?

并没有大的提高，甚至反而所下降。猜测问题在于我使用的amb实现是call/cc、宏实现的，待俺完成amb求值器再测试一下。

4.40，题目都提示咯，嵌套let语句,我的解答：

(define (multiple-dwelling2)
  (let ((baker   (amb 1 2 3 4 5)))
     (require (not (= baker 5)))
      (let ((cooper  (amb 1 2 3 4 5)))
        (require (not (= cooper 1)))
        (let ((fletcher (amb 1 2 3 4 5)))
          (require (not (= fletcher 5)))
          (require (not (= fletcher 1)))
          (require (not (= (abs (- fletcher cooper)) 1)))
          (let ((miller (amb 1 2 3 4 5)))
             (require (> miller cooper))
             (let ((smith   (amb 1 2 3 4 5)))
                (require (not (= (abs (- smith fletcher)) 1)))
                (require (distinct? (list baker cooper fletcher miller smith)))
                (list (list 'baker baker)
                      (list 'cooper cooper)
                      (list 'fletcher fletcher)
                      (list 'miller miller)
                      (list 'smith smith))))))))

profile一下，multiple-dwelling2的调用时间缩小到8毫秒，require和distinct?的调用次数分别降低到了404和129次。

4.42，说谎者谜题，
五个女生参加一个考试，她们的家长对考试结果过分关注。为此她们约定，在给家里写信谈到考试的时候，每个姑娘都要写一句真话和一句假话。下面是从她们的信里摘抄出来的句子：
Betty : kitty考第二，我只考了第三
Ethel : 你们应该很高兴听到我考了第一，joan第二
joan : 我考第三，可怜的Ethel垫底
kitty: 我第二，marry只考了第四
marry: 我是第四，Betty的成绩最高。
这五个姑娘的实际排名是什么？

将题目翻译成代码就OK了，说明性编程真是舒坦：

(define (liars-puzzle)
  (let ((betty (amb 1 2 3 4 5))
        (ethel (amb 1 2 3 4 5))
        (joan (amb 1 2 3 4 5))
        (kitty (amb 1 2 3 4 5))
        (marry (amb 1 2 3 4 5)))
    (require
       (distinct? (list betty ethel joan kitty marry)))
    (require (or (= kitty 2) (= betty 3)))
    (require (not (and (= kitty 2) (= betty 3))))
    (require (or (= ethel 1) (= joan 2)))
    (require (not (and (= ethel 1) (= joan 2))))
    (require (or (= joan 3) (= ethel 5)))
    (require (not (and (= joan 3) (= ethel 5))))
    (require (or (= kitty 2) (= marry 4)))
    (require (not (and (= kitty 2) (= marry 4))))
    (require (or (= marry 4) (= betty 1)))
    (require (not (and (= marry 4) (= betty 1))))
    (list (list 'betty betty)
          (list 'ethel ethel)
          (list 'joan joan)
          (list 'kitty kitty)
          (list 'marry marry))))

答案是：
((betty 3) (ethel 5) (joan 2) (kitty 1) (marry 4))

4.43.也很有趣的题目，游艇迷题，
Mary Ann Moore的父亲有一条游艇，他的四个朋友Colonel Dowing、Mr.Hall、Sir Barnacle Hood和Dr.Parker也各有一条。这五个人都有一个女儿，每个人都用另一个人的女儿的名字来为自己的游艇命名。Sir Barnacle的游艇叫Gabrielle，Mr.Moore拥有Lorna，Mr.Hall的游艇叫Rosalind，Melissa属于Colonel Downing（取自Sir Barnacle的女儿的名字），Garielle的父亲的游艇取的是Dr.Parker的女儿的名字。请问，谁是Lorna的父亲。

先说下结果，Lorna的父亲是Downing。
具体解答如下,先定义辅助过程：

(define (father yacht daughter)
     (cons yacht daughter))
(define (yacht father)
  (car father))
(define (daughter father)
  (cdr father))

然后翻译题目为代码即可，暂不考虑效率问题：

(define (yacht-puzzle)
  (let ((moore (father 'lorna 'mary))  ;;Mr.Moore
        (downing (father 'melissa (amb 'mary 'melissa 'gabrielle 'rosalind 'lorna))))  ;;Colonel Downing
    (require (not (equal? (yacht downing) (daughter downing))))
    (let ((hall (father 'rosalind (amb 'mary 'melissa 'gabrielle 'rosalind 'lorna))))  ;;Mr.Hall
       (require (not (equal? (yacht hall) (daughter hall))))
       (let ((barnacle (father 'gabrielle 'melissa))   ;;Sir Barnacle Hood
             (parker (father (amb 'mary 'melissa 'gabrielle 'rosalind 'lorna) (amb 'mary 'melissa 'gabrielle 'rosalind 'lorna))))         ;;Dr.Parker
         (require (not (equal? (yacht parker) (daughter parker))))
         (let ((gabrielle-father (amb moore downing hall barnacle parker))) ;;Garielle's Father
           (require (equal? (daughter gabrielle-father) 'gabrielle))
           (require (equal? (yacht gabrielle-father) (daughter parker)))
           (require (distinct? (map daughter (list moore downing hall barnacle parker))))
           (require (distinct? (map yacht (list moore downing hall barnacle parker))))
           (list
              (list 'moore (yacht moore) (daughter moore))
              (list 'downing (yacht downing) (daughter downing))
              (list 'hall (yacht hall) (daughter hall))
              (list 'barnacle (yacht barnacle) (daughter barnacle))
              (list 'parker (yacht parker) (daughter parker))))))))

运行(yacht-puzzle)的结果为：
((moore lorna mary) (downing melissa lorna) (hall rosalind gabrielle) (barnacle gabrielle melissa) (parker mary rosalind))

三元组：父亲名、游艇名、女儿名，因此lorna的父亲是Downing。Garielle的父亲是Mr.Hall，Mr.Hall的游艇名叫做Rosalind，正是Dr.Parker的女儿名字。

延伸题目，如果没有Mary Ann姓Moore这个条件，答案将有三个，分别是：
((moore lorna mary) (downing melissa lorna) (hall rosalind gabrielle) (barnacle gabrielle melissa) (parker mary rosalind))
((moore lorna gabrielle) (downing melissa rosalind) (hall rosalind mary) (barnacle gabrielle melissa) (parker mary lorna))
((moore lorna lorna) (downing melissa mary) (hall rosalind gabrielle) (barnacle gabrielle melissa) (parker mary rosalind))

dennis 2008-11-15 00:02 发表评论

sicp 4.3.1小节两题

dennis — Mon, 03 Nov 2008 17:20:00 GMT

本节开始介绍神奇的amb函数，为引入逻辑程序设计做铺垫。关于amb，有清华王垠的一个文档：
http://cs2.swfc.edu.cn/~wanghuan/wangyin1/amb/amb.html

4.35，与an-element-of类似：

(define (an-integer-between low high)
(require (not (> low high)))
(amb low (an-integer-between (+ low 1) high)))

4.36,与练习3.69相关，貌似我没解过这道题，略过。

4.37,两点大大缩小了搜索范围：
1）通过限制i^2+j^2<= high^2，平方和大于上限平方的全部过滤掉
2）k的判断不再通过amb取值，而是求平方和的平方根是否为整数来判断，进一步缩小了搜索范围

dennis 2008-11-04 01:20 发表评论

sicp 4.2.2小节部分习题

dennis — Sat, 01 Nov 2008 17:18:00 GMT

4.27，

;;; L-Eval input:
(define count 0)

;;; L-Eval value:
ok

;;; L-Eval input:
(define (id x)
(set! count (+ 1 count))
x)

;;; L-Eval value:
ok

;;; L-Eval input:
(define w (id (id 10)))

;;; L-Eval value:
ok

;;; L-Eval input:
count

;;; L-Eval value:
1

;;; L-Eval input:
w

;;; L-Eval value:
10

;;; L-Eval input:
count

;;; L-Eval value:
2

至于原因，w在没有强迫求值前，仅仅执行了一步(id 10)，因此此时count为1，当要求打印w的时候force执行了第二步(id 10)，因此count增加为2。

4.28，当参数也是函数的时候，例如：

(define square (lambda(x) (* x x)))
(define (test proc a)
(proc a))
(test square 3)

如果对operator不采用actual-value，那么square将延时求值，在执行(proc a)时无法辨认eval的过程类型。

4.29，俺第一个想到的就是树形递归的斐波那契数列：

(define (fib n)
  (cond ((= 0 n) 0)
            ((= 1 n) 1)
            (else
              (+ (fib (- n 1)) (fib (- n 2))))))

不带记忆功能和带记忆功能的force-it之间的性能差距非常明显。

第二问，有趣的地方在于square过程，注意到(define (square x) (* x x))，x在body出现了两次，那么如果是使用不带记忆功能的force-it， x将被求值两次，如果x本身带有副作用（例如例子里面的id过程），那么显然副作用也将被调用两次，因此答案不言自明。带记忆功能的force-it版本中，count将仍然是1，而在不带记忆功能的版本中count将增长到2。

4.30，第一问，我也谈不出所以然为什么ben的说法是正确的，关注下第二问的两个过程在不同eval-sequence下的表现，(p1 1)的结果没有改变都是(1 2)，而(p2 1)在原始版本的eval-sequence中结果是1，而在Cy修改后的版本中(对中间步骤采用actual-value)结果是(1 2)，也就是说在原始版本中的(set! x (cons x '(2)))的副作用根本没有实现，而在修改后的版本中实现了。俺觉的这个问题很迷惑，惰性求值与side effect相互作用很奇特，不过我更偏向原始版本，因为我觉的这样的实现更容易看清代码的意图，也就是说在透明性上更好，例如我分析p2过程就可以认为直接返回参数x；而实现副作用很容易让人掉入陷阱，并且很可能引进难以查找的bug。

dennis 2008-11-02 01:18 发表评论

sicp 4.2.1两题

dennis — Fri, 31 Oct 2008 15:12:00 GMT

4.25，如果在scheme解释器的应用序求值下,unless定义为一个过程，那么
(* (factorial (- n 1))
将无穷递归下去。如果在正则序时，由于延时求值，仅当需要计算时才求值此表达式，不会造成无穷递归，在1的时候正常结束递归。

4.26，在上一节求值器的基础上定义unless的语法形式还是很简单的，
首先在analyze过程添加分析unless:

((unless? exp) (analyze (unless->if exp)))

然后定义unless?和unless->if

(define (unless? exp)
(tagged-list? exp 'unless))
(define (unless->if exp)
(make-if (cadr exp) (cadddr exp) (caddr exp)))

最后一问，构造一个unless与高阶函数联合使用的场景，在此场景下，unless不能定义成特殊形式，仅在定义成过程的情况下有效，我想像不出此场景。

dennis 2008-10-31 23:12 发表评论

漂亮的代码

dennis — Thu, 09 Oct 2008 15:58:00 GMT

    Ruby的创造者为《代码之美》撰写的文章标题是《代码如散文》。程序和散文有一些共性，首先是两者都必须有清晰的意图，散文内容是什么，想表达什么，程序的功能是什么，能做什么；其次两者在意图的表达上（功能的实现上）都依赖于写作的具体风格，编程的隐喻之一就是写作。你想表达的思想是好的，但是如果表达得难以理解，那么要把这个思想传播给读者将非常困难。代码被读和修改的次数是相当多的，因此一个很重要的观点就是你写的代码是给人读的，你需要考虑可读性的问题，归结于写出漂亮的代码。
   判断代码是否漂亮似乎没有什么国家标准，更没有国家免检。代码是写给人读的，从这个角度上看，如果一段代码能让人很容易地读懂，让人感觉心情愉快，修改起来也不费什么力气，这似乎就是漂亮的代码咯。那么显然，漂亮的代码的真正含义是帮助程序员感到快乐和提高生产率。有了这个指导性的方向，你可以从这么几个方面去努力写出漂亮的代码：简洁性、保守性、简单性、灵活性和平衡。
   简洁性，文中以Ruby和Java版本的Hello World入手比较，在Ruby和其他动态语言中，你所做的就是你想表达的：打印Hello World

print "Hello World\n"

换成java，哦，你先要定义一个类，这个类有个入口main方法，在main方法中调用System.out对象的println方法打印：

class Sample{
   public static void main(String []args){
     System.out.println("Hello World");
   }
}

我记的我初学java的时候就特别不理解为什么要定义一个类，为什么方法要static、args，而我仅仅想要的只是打印一个字符串，可语言硬塞给了我太多的概念：类、方法、入口、参数。这些额外的东西牵扯了太多的注意力，而往往却忘记了初衷是什么。因此在《unix编程艺术》一书中对OO的一个评价是：鼓励具有厚重的胶合和复杂层次的体系，大大降低了代码的简洁性和透明性，你无法一眼看出代码是想做什么的。OO的抽象能力很强大，因此在很多场景下是这种抽象能力的滥用，实现最简单的功能也是一定要有类，有类才有对象，有对象才有光：）而往往这些对象却非问题领域中的自然实体，而是某种胶合物，为了抽象而抽象。
简洁同样意味着消除冗余。代码的重复是万恶之源，拷贝黏贴是滋生bug的温床，在重构概念如此深入人心的今天，这一点毋庸置疑。因此，谨记请DRY原则。语言级别的冗余可能是需要的，例如Ruby允许方法调用省略括号：

task :name=>:test
task({:name=>:test})

这两行代码想表达的意思一样，显然第一种方式更简洁，这种语言级别的冗余显然是有利于程序员的，尽管将实现的难度推给了语言的设计和实现者。
   漂亮代码另一个有争议的方面就是它的熟悉性，人们对于新东西的接受程度远没有想象中的高，大家都喜欢自己熟悉的东西而非全新的思考方式（嗯，极客例外）。这其实是Ruby一直鼓吹的最小惊奇原则的另一种表达。Ruby看来就是这么个保守的语言，他有很强大的OO能力，但是没有全然照搬smalltalk，他有FP的能力但是却没有让你惊掉下巴，他仍然遵循着古老的顺序、循环、选择的程序结构。
   简单性强调是减轻程序员的工作负担，语言和类库API的优化应当有利于使用者，将困难留给实现者。前面提到的语言的冗余性就是一例。程序的复杂性来源有这么几个：商业上基于推销热点而非实际需求考虑出发带来的“特性清单”、业务领域本身的复杂度、程序员的自傲心理，最根本在于软件的开发的复杂性。如果能将复杂的功能，用人人理解的简单代码表达出来，当然漂亮！
   简单并不意味着简陋，保守也不意味着死板。灵活性同样是代码漂亮与否的判断标准，是否隔离了变化点，是否拥有一定的扩展能力，是否无需借助工具的增强而实现某些巧妙的调用。同样以Ruby为例，open class和元编程给了内置你在语言级别的“工具”，你无需借助antlr、cglib等等类库去做一些看似复杂的东西。你将感受到编程的快乐，而非为了工具而去做一些违背本意的事情。灵活性可能是把双刃剑，过分的强调灵活性、可扩展性也可能带来复杂的代码，注意你的“炫耀”心理。
   最后要强调的是平衡，在这些因素之间做出平衡，我觉的吧，没有更多实践的经验想平衡这些因素是相当困难的，如果了解了平衡的艺术，也许算是透出那么点“编程的艺术”的味道。Matz一直强调的一点是编程的乐趣，如果没有乐趣，我想我不会干这行，如果没有乐趣，我想我的工作效率将极度低下，从你认为是枯燥的工作中找乐子，存了这么个心理，你总能找出很多可以做的有趣事情，问题在于，你肯不肯做？

ps.加张图片，俺的blog国家免检

dennis 2008-10-09 23:58 发表评论

远程调用的语义

dennis — Tue, 19 Aug 2008 15:47:00 GMT

    远程调用由于涉及到服务器和客户端等多个节点以及需要通过网络通讯等，会引入更多的故障可能。本地调用的语义都是恰好一次，不会多也不会少。而远程调用的语义就比较复杂，依据三个选择将产生不同的语义：
1）重发请求消息：客户端是否重发请求，直到收到应答或者认定服务器故障为止
2）过滤重复消息：当客户端重发请求时候，服务器是否过滤重复的请求
3）重传结果：服务器是否保存结果消息的历史，以便服务器不用重新执行操作就能重传结果。

对这三个选择的不同组合将产生三种可能的远程调用语义：
重发请求消息过滤重复消息重传结果            语义

否            不适用       不适用             或许
是            否           重新执行操作       至少一次
是            是           重传结果           至多一次

或许调用语义：远程方法可能执行一次，或者根本不执行（在消息遗漏或者服务器崩溃的情况下）

至少一次调用语义：远程方法要嘛至少执行一次并返回结果，要嘛返回一个异常。因为启用了重发请求消息，服务器也重新执行操作，因此远程调用至少执行一次，除非服务器崩溃；但是，由于服务器重新执行操作，如果调用不是幂等的，那么多次重复执行将产生副作用叠加，可能不符合预期需求。对于幂等操作，至少一次调用语义是可以接受的。

至多一次调用语义：在此语义下，服务器会过滤重复的请求，并且缓存执行的结果重传而非重新执行。因此远程调用同样也是返回调用结果，或者一个异常。在返回结果的情况下，可以确认服务器恰好执行一次，与本地调用语义一样，不会有副作用叠加。如果返回异常，就是通知调用者没有返回结果，远程调用要嘛执行了一次，要嘛根本没有执行。总之，远程调用至多执行一次。

Java RMI的调用语义是至多一次。

dennis 2008-08-19 23:47 发表评论

TCP的TIME_WAIT状态

dennis — Sun, 22 Jun 2008 17:25:00 GMT

    主动关闭的Socket端会进入TIME_WAIT状态，并且持续2MSL时间长度，MSL就是maximum segment lifetime(最大分节生命期），这是一个IP数据包能在互联网上生存的最长时间，超过这个时间将在网络中消失。MSL在RFC 1122上建议是2分钟，而源自berkeley的TCP实现传统上使用30秒，因而，TIME_WAIT状态一般维持在1-4分钟。
    TIME_WAIT状态存在的理由：
1）可靠地实现TCP全双工连接的终止
    在进行关闭连接四路握手协议时，最后的ACK是由主动关闭端发出的，如果这个最终的ACK丢失，服务器将重发最终的FIN，因此客户端必须维护状态信息允许它重发最终的ACK。如果不维持这个状态信息，那么客户端将响应RST分节，服务器将此分节解释成一个错误（在java中会抛出connection reset的SocketException)。因而，要实现TCP全双工连接的正常终止，必须处理终止序列四个分节中任何一个分节的丢失情况，主动关闭的客户端必须维持状态信息进入TIME_WAIT状态。

2）允许老的重复分节在网络中消逝
    TCP分节可能由于路由器异常而“迷途”，在迷途期间，TCP发送端可能因确认超时而重发这个分节，迷途的分节在路由器修复后也会被送到最终目的地，这个原来的迷途分节就称为lost duplicate。在关闭一个TCP连接后，马上又重新建立起一个相同的IP地址和端口之间的TCP连接，后一个连接被称为前一个连接的化身（incarnation)，那么有可能出现这种情况，前一个连接的迷途重复分组在前一个连接终止后出现，从而被误解成从属于新的化身。为了避免这个情况，TCP不允许处于TIME_WAIT状态的连接启动一个新的化身，因为TIME_WAIT状态持续2MSL，就可以保证当成功建立一个TCP连接的时候，来自连接先前化身的重复分组已经在网络中消逝。

新的SCTP协议通过在消息头部添加验证标志避免了TIME_WAIT状态。

dennis 2008-06-23 01:25 发表评论

sicp4.1.1-4.1.5节部分习题尝试解答(update)

dennis — Sun, 01 Jun 2008 07:51:00 GMT

当将用scheme写的scheme求值器跑起来的时候，你不觉的兴奋是不可能的，真的太酷了，太magic了。
习题4.2，如果将application？判断放在define?判断之前，那么求值(define x 3)将把define当作一般的procedure应用于参数x和3，可是define是特殊的语法形式，而非一般过程，导致出错。
习题4.4，我的解答，eval增加两个判断：

((and? exp)
(eval-and (and-exps exp) env))
((or? exp)
(eval-or (or-exps exp) env))

实现谓词和各自的过程：

(define (and? exp)
  (tagged-list? exp 'and))
(define (and-exps exp)
  (cdr exp))
(define (eval-and exps env)
  (cond ((null? exps)
          'true)
        (else
          (let ((result (eval (car exps) env)))
            (if (not result)
                result
                (eval-and (cdr exps) env))))))
(define (or? exp)
  (tagged-list? exp 'or))
(define (or-exps exp) (cdr exp))
(define (eval-or exps env)
  (cond ((null? exps)
         'false)
        (else
         (let ((result (eval (car exps) env)))
           (if result
               result
               (eval-or (cdr exps) env))))))

如果用宏实现就简单了：

(define-syntax and
(syntax-rules ()
      ((_) #t)
      ((_ e) e)
      ((_ e1 e2 e3 )
        (if e1 (and e2 e3 ) #f))))
(define-syntax or
   (syntax-rules ()
             ((_) #f)
             ((_ e) e)
             ((_ e1 e2 e3 )
              (let ((t e1))
                  (if t t (or e2 e3 ))))))

习题4.5，cond的扩展形式，也不难，在else子句之外增加个判断，是否带有=>符号，修改expand-clauses过程：

(define (cond-extended-clauses? clause)
(and (> (length clause) 2) (eq? (cadr clause) '=>)))
(define (extended-cond-test clause)
(car clause))
(define (extended-cond-recipient clause)
(caddr clause)
(define (expand-clauses clauses)
  (if (null? clauses)
      'false
      (let ((first (car clauses))
            (rest (cdr clauses)))
        (cond ((cond-else-clauses? first)
                (if (null? rest)
                    (sequence->exp (cond-actions first))
                    (error "else clause is not LAST" clauses)))
              ((cond-extended-clauses? first) ;判断是否扩展形式
               (make-if
                   (extended-cond-test first)
                    (list
                      (extended-cond-recipient first)
                      (extended-cond-test first))
                      (expand-clauses rest)))
              (else
               (make-if (cond-predicate first)
                        (sequence->exp (cond-actions first))
                        (expand-clauses rest)))))))

习题4.6，let如果用宏定义，类似这样：

(define-syntax let
  (syntax-rules ()
    ((_ ((x v) ) e1 e2 )
     ((lambda (x ) e1 e2 ) v ))))

求值器扩展，实现let->combination过程：

(define (let? exp)
  (tagged-list? exp 'let))
(define (let->combination exp)
  (let ((vars (map car (cadr exp)))
        (vals (map cadr (cadr exp)))
        (body (caddr exp)))
  (cons (make-lambda vars (list body)) vals)))

我们做的仅仅是syntax transform，将let转成对应的lambda形式。

习题4.7，这里的关键在于let*->netsted-lets要递归调用，从let*的宏定义可以看出：

(define-syntax let*
     (syntax-rules()
       ((_ ((var1 val1)) e1 )
        (let ((var1 val1)) e1 ))
       ((_ ((var1 val1) (var2 val2) ) e1 )
        (let ((var1 val1))
          (let* ((var2 val2) )
            e1 )))))

那么，let*->nested-lets可以定义为：

(define (let*? exp)
  (tagged-list? exp 'let*))
(define (let*->nested-lets exp)
     (let ((pairs (cadr exp))
           (body (caddr exp)))
       (if (null? (cdr pairs))
           (list 'let pairs body)
           (list 'let (list (car pairs)) (let*->nested-lets (list 'let* (cdr pairs) body))))))

测试一下：
(let* ((x 1) (y (+ x 3))) (+ x y)) =》5

习题4.8，命名let，修改let->combination过程，判断cadr是pair还是symbol，如果是前者，那就是一般的let，如果是symbol就是命名let语句，那么需要定义一个名为(cadr exp)的过程放在body里，注意，我们是在做语法转换，因此，这个定义也应该描述成符号，定义一个make-define过程来生成define语句：

(define (make-define var parameters body)
(list 'define (cons var parameters) body))

然后修改let->combination过程，如上所述：

(define (let->combination exp)
  (if (symbol? (cadr exp))
      (let ((var (cadr exp))
            (vars (map car (caddr exp)))
            (vals (map cadr (caddr exp)))
            (pairs (caddr exp))
            (body (cadddr exp)))
        (cons (make-lambda vars (list (make-define var vars body) body)) vals))
      (let ((vars (map car (cadr exp)))
            (vals (map cadr (cadr exp)))
            (body (caddr exp)))
              (cons (make-lambda vars (list body)) vals))))

习题4.1.4，原生的map过程接受的procedure，是以scheme内在数据结构表示的procedure，而在我们的求值器中，procedure的内在数据结构取决于我们，与原生的结构不同，导致原生的map无法接受自制求值器的procedure，如果map也以求值器中的结构定义，那么就没有这个问题。因此，本质上的困难就在于两个求值器对procedure的数据结构表示的不同。

习题4.1.5，著名的图灵停机问题，先是假设存在halts?过程可以正确地判断任何过程p和对象a是否p对a终止，定义了try过程：
(define (try p)
   (if (halts? p p)
       (run-forever)
        'halted))
当执行(try try),如果这个过程可终止，那么(halts? try try)应该返回false，也就是try过程对try不会终止，这与一开始的假设矛盾；如果这个过程将无穷运行下去，那么(halts? try try)应该返回true，也就是try对try终止，这也与(try try)将无穷运行的假设矛盾。因此，可以推论出，我们不可能写出一个过程halts?，使它能正确地判断任何过程p和对象a是否p对a终止。

dennis 2008-06-01 15:51 发表评论

sicp3.5.2、3.5.3节部分习题尝试解答

dennis — Tue, 13 May 2008 15:52:00 GMT

本节主要讲述无穷流。
3.53，显然

(define s (cons-stream 1 (add-stream s s)))

定义是2的n次方组成的无穷数列，2,4,8,16,32...

3.54，定义阶乘组成的无穷序列：

(define (mul-streams s1 s2)
(stream-map * s1 s2))
(define factorials (cons-stream 1 (mul-streams factorials (stream-cdr integers))))

3.55解答，比较有趣，也是不难的题目，列出来找出规律就成了，就是将(stream-car s)加到生成的序列中的每个元素上，通过stream-map，最后的结果就是每个元素都是前n个元素累积的结果，我的解答：

(define (partial-sums s)
(cons-stream (stream-car s) (stream-map (lambda(x) (+ x (stream-car s))) (partial-sums (stream-cdr s)))))

3.56，有了merge就好办了，根据条件合并起3种情况来就好：

(define S (cons-stream 1 (merge (scale-stream s 2) (merge (scale-stream s 3) (scale-stream s 5)))))

3.57,略过

3.58，观察到，num每次都与radix相乘并且radix保持不变，那么radix可以认为是一个基数，den也保持不变作为除数，那么这个序列就是以radix为基数对den求整数商的序列，不明白num为什么每次要变换成余数？这个序列有啥特别的用途呢？未解。

(expand 1 7 10)

=> 1 4 2 8 5 7 1 4 2 8



(expand 3 8 10)

=> 3 7 5 0 0 0 0 0 0 0

3.59解答：
a)只要将序列通过前面定义的mul-streams与整数的倒数序列相乘：

(define (integrate-series s)
(mul-streams (stream-map (lambda(x) (/ 1 x)) integers) s))

b)照着定义来了，cons的级数注意使用scale-stream乘以-1：

(define sine-series
  (cons-stream 0 (integrate-series cosine-series)))

(define cosine-series
  (cons-stream 1
    (scale-stream
      (integrate-series sine-series)
      -1)))

3.64解答：

(define (stream-limit s tolerance)
  (define (stream-limit-iter stream current)
    (cond ((or (stream-null? stream) (null? (stream-car stream))) #f)
          (else
           (let ((next (stream-car stream)))
             (if (< (abs (- next current)) tolerance)
                   next
                  (stream-limit-iter (stream-cdr stream) next))))))
  (stream-limit-iter (stream-cdr s) (stream-car s)))

习题3.65：

(define (ln-summands n)
(cons-stream (/ 1.0 n)
(stream-map - (ln-summands (+ n 1)))))
(define ln-stream (partial-sums (ln-summands 1)))
(define ln-stream2 (euler-transform ln-stream))
(define ln-stream3 (accelerated-sequence euler-transform ln-stream))

经过欧拉变换加速过的级数收敛的很快，测测就知道

dennis 2008-05-13 23:52 发表评论

scheme解决约瑟夫环问题（续）

dennis — Wed, 16 Apr 2008 02:27:00 GMT

sicp的习题3.22，也就是以消息传递的风格重新实现队列，我的解答如下：

(define (make-queue)
  (let ((front-ptr '())
        (rear-ptr '()))
  (define (set-front-ptr! ptr) (set! front-ptr ptr))
  (define (set-rear-ptr! ptr) (set! rear-ptr ptr))
  (define (empty-queue?) (null? front-ptr))
  (define (front-queue)
    (if (empty-queue?)
        (error "FRONT called with an empty queue")
        (car front-ptr)))
  (define (insert-queue! item)
    (let ((new-pair (cons item '())))
      (cond ((empty-queue?)
              (set-front-ptr! new-pair)
              (set-rear-ptr! new-pair))
            (else
               (set-cdr! rear-ptr new-pair)
               (set-rear-ptr! new-pair)))))
  (define (delete-queue!)
      (cond ((empty-queue?)
             (error "DELETE! called with an empty queue" queue))
            (else
               (set-front-ptr! (cdr front-ptr)))))
  (define (dispatch m)
    (cond ((eq? m 'front-queue) (front-queue))
          ((eq? m 'empty-queue?) (empty-queue?))
          ((eq? m 'insert-queue!) insert-queue!)
          ((eq? m 'delete-queue!) delete-queue!)
          (else
             (error "Unknow method" m))))
    dispatch))
(define (front-queue z) (z 'front-queue))
(define (empty-queue? z) (z 'empty-queue?))
(define (insert-queue! z item) ((z 'insert-queue!) item))
(define (delete-queue! z) ((z 'delete-queue!)))

由此，我才知道自己竟然一直没有想到，scheme完全可以模拟单向循环链表，整整第三章都在讲引入赋值带来的影响，而我却视而不见。在引入了改变函数后，数据对象已经具有OO的性质，模拟链表、队列、table都变的易如反掌。首先，模拟节点对象，节点是一个序对，包括当前节点编号和下一个节点：

(define (make-node n next) (cons n next))
(define (set-next-node! node next) (set-cdr! node next))
(define (set-node-number! node n) (set-car! node n))
(define (get-number node) (car node))
(define (get-next-node node) (cdr node))

有了节点，实现了下单向循环链表：

(define (make-cycle-list n)
  (let ((head (make-node 1 '())))
    (define (make-list current i)
      (let ((next-node (make-node (+ i 1) '())))
        (cond ((= i n) current)
              (else
                (set-next-node! current next-node)
                (make-list next-node (+ i 1))))))
    (set-next-node! (make-list head 1) head)
    head))

make-cycle-list生成一个有N个元素的环形链表，比如(make-cycle-list 8)的结果如下
#0=(1 2 3 4 5 6 7 8 . #0#)
Drscheme形象地展示了这是一个循环的链表。那么约瑟夫环的问题就简单了：

(define (josephus-cycle n m)
  (let ((head (make-cycle-list n)))
    (define (josephus-iter prev current i)
      (let ((next-node (get-next-node current)))
       (cond ((eq? next-node current) (get-number current))
             ((= 1 i)
              (set-next-node! prev next-node)
              (josephus-iter prev next-node m))
             (else
               (josephus-iter current next-node (- i 1))))))
    (josephus-iter head head m)))

从head节点开始计数，每到m，就将当前节点删除（通过将前一个节点的next-node设置为current的下一个节点），最后剩下的节点的编号就是答案。

dennis 2008-04-16 10:27 发表评论

关于binary search

dennis — Wed, 02 Apr 2008 02:08:00 GMT

编程珠玑Column 4关于binary search的部分相当精彩，1946年就有人发表binary search，但直到1962第一个正确运行的算法才写出来。尽管算法描述看起来简单明了，但是要写的正确却是有许多地方要仔细考虑。作者着重强调的是对程序正确性的分析方法，仔细分析方法的pre-condition, invariant,和post-condition。g9老大翻译过Joshua Bloch在google blog上的文章《号外，号外，几乎所有的binary search和mergsort都有错》，原文在这里。今天看了下原文，有更新，对于求中值索引的c/c++方法原文仍然是有错的，本来是这样：

int mid = ((unsigned) (low + high)) >> 1。

但是在c99标准中，对于两个signed数值之和，如果溢出结果是未定义的(undefined)，也就是说与编译器实现相关。上面的代码应该修改为：

mid = ((unsigned int)low + (unsigned int)high)) >> 1;

我查了下jdk6的java.util.Arrays的源码，joshua bloch说的这个问题已经解决，现在的binary search如下：

  // Like public version, but without range checks.
    private static int binarySearch0(int[] a, int fromIndex, int toIndex,
                     int key) {
    int low = fromIndex;
    int high = toIndex - 1;

    while (low <= high) {
        int mid = (low + high) >>> 1;
        int midVal = a[mid];

        if (midVal < key)
        low = mid + 1;
        else if (midVal > key)
        high = mid - 1;
        else
        return mid; // key found
    }
    return -(low + 1);  // key not found.
    }

如原文所讨论的，采用了>>>操作符替代除以2

dennis 2008-04-02 10:08 发表评论