Footprint的实现让我有机会体验了HTML5的一些特性，比如Geo Location，Local DB，File API等，另外，对node.js也进行了尝试，实现了一个简单（还不完整）的WebServer。

  更重要的，是在JavaScript实践上尝试和印证了一些想法，比如ActiveRecord的JS实现，引入Custom Data Attributes之后对数据流的重新定向等等。

  但这次作业的教训也很深刻，作为一个技术人员，在产品设计和UI设计上缺乏太多的常识和感觉。最近看了《瞬间之美 》后感触更深。这方面也是最近三个月的一个提升目标。

  关于这个应用更详细的介绍请到这里：https://github.com/andyhu1007/bapi。

----EOF-----

• —软件人才免语言低担保 赴美带薪读研！—

  Scala通过强调对象的不变性 以及使用基于事件的模型进行线程间通信 使得实现并发应用变得简单。

  不变对象

  并发编程之所以这么困难，很大一个原因在于对象的可变性。要在充斥着大量可变对象的程序里面实现安全并发，需要非常繁琐以及复杂易错的同步操作来保证状态更新的同步。

  比如下面这段代码（java的例子），可能你会认为它已经是线程安全的了，因为所有的方法都已经被同步。

class Account {
    private int balance;
    
    synchronized public int getBalance() {
      return balance;
    }
    
    synchronized public void incrementBalance() {
      balance++;
    }
}

  但是问题来了，当顺序调用这两个方法的时候，比如：

account.incrementBalance();
account.getBalance();

  这时并不是线程安全的，在第一个方法调用结束之后，可能会被其它线程获取对象的锁，修改account的balance。

  在命令式编程语言里面，命令查询分离是一个普遍使用的原则。意即：一个方法要么进行一次命令（执行一个操作，通常会修改状态），要么进行一次查询（返回一些状态， 但并不修改状态），而不应该同时执行命令以及查询。从面向对象的角度看，这是一个良好的设计；但从并发编程的角度看，它却带来了一些问题，使得并发编程实现更加困难。上面就是一个很好的例子。

  要使得上面这段代码变得线程安全，可以通过破坏命令查询分离原则来实现：

synchronized public int incrementAndGetBalance() {
  balance++;
  return balance;
}

  从上面的例子看到，在可变对象的环境中实现并发编程是困难的。而不变对象，意即线程安全的对象，使得我们不必担心共享对象会被多个线程同时修改而无法保持它的正确性：因为它本身就不可修改。我们可以把不变对象很放心地扔到多线程环境中，任意使用。

  问题又来了，如果要“修改状态”怎么办？很简单，创建一个新的对象。还是上面那个例子，我们把它修改成一个Scala的不变对象类。并在伴生对象里面实现increment方法，此方法会返回一个新的account对象，balance值为原有对象的值加1所得。

class Account (val balance: Integer) {
  def getBalance() = balance
}

object Account {
  def increment(account: Account): Account {
    new Account(account.getBalance() + 1)
  }
}

 通过强调不变对象的使用，并发编程变得简单了很多。

 Actor

 传统的并发是通过线程（thread）来实现的。在传统的并发模型中，程序被分成若干份同时执行的任务，并且所有任务都对一块共享的内存进行操作。在传统的并发模型会引起竞争问题，可以采取锁机制避免竞争问题，但同时这可能带来死锁等问题。

 Actor模型是另一种不同的并发模型，它很好地解决了在传统并发模型中竞争和死锁等问题。我们可以把一个由actor模型实现的并发程序看成是一个星系一样，星系里面有很多星球，每个星球都是一个actor，星球之间不共享任何资源，但是它们之间有通道来相互传递信息。

 每个星球（actor）都有一个信箱来接受来自其它星球的任意信息，它会按照信息接收的顺序来处理，处理完一个信息然后接着处理下一个信息。可以按照信息类型来触发不同的行为。

 同时，每个星球（actor）可以异步地（也可以同步，但不是这里谈论的重点）向其它任意星球发送任意消息，就是说，它发送消息之后不会等待返回信息而是直接执行接下来的操作。

  下面是一个Actor的例子：

import scala.actors.Actor
import scala.actors.Actor._
 
case class Increment(amount: Int)
case class Balance
 
class Account extends Actor {
    var balance: Int = 0;
 
    def act() = {
        while (true) {
            receive {
                case Increment(amount) =>
                    balance += amount
                case Balance =>
                    println("Balance is " + balance)
                    exit()
            }
        }
    }
}

  我们可以看到，程序里面定义两种不同的消息类型：Increment和Balance。Account是一个Actor，它跟外界的交互都是通过消息传递来实现：不论是increment，还是获取balance都是通过消息的方式来实现。当接受到不同的消息时，它会执行不同的行为。

  我们也可以看到，Account的内部状态完全是自己控制的，接收到的消息是顺序执行的，所以我们不需要担心竞争问题。

 小结

  Scala就是这样，通过“使用基于事件的模型进行线程间通信”，并且“把不变对象作为消息进行传递”来实现一个并发编程模型。

--EOF--

• —软件人才免语言低担保 赴美带薪读研！—

Ext JS的主要特点是组件化，Web客户端的常见显示和行为，数据的处理以及服务器端的通信都通过组件的方式进行包装。比如表单、toolbar、下拉框、viewport以及tree等页面常见表现和行为，JSON和XML等数据类型的处理以及AJAX等行为的封装，都有相应的专门组件。

这种处理方式的目的是对“数据”和“表现行为”进行隔离，让程序员摆脱HTML，CSS和JavaScript，而只需要关注跟强大的Ext JS组件接口的交互。但接口的学习和熟悉其实也需要一定的成本。

这种方式带来了一些很大的问题：

1. 对“表现以及行为” -- 既HTML, CSS和JavaScript -- 的隔离和封装，使程序员失去了对这些代码的直接控制。
2. 也是由于隔离，不得已造成了“邪恶的代码生成”。
3. 这种方式也造成了HTML，CSS和JavaScript的高度耦合。

个人非常不推崇这种绑架用户的实现理念。Ext JS虽然强大，但却以失去自由为代价。

而相反，JQuery中多数插件以“注入方式”实现，比如在HTML tag添加一个class并会引入相应的表现和行为。这种低耦合的实现方式才是正确并值得推崇的。

最后，《Learning Ext JS》 中有一句话感同深受：Web应用发展的一个奇观是，经过一个轮回之后，又回归到客户端/服务端的应用模型。

--EOF--

• —软件人才免语言低担保 赴美带薪读研！—

用户注册需要多个步骤，比如填写完基本信息，通过验证之后，来到联系信息填写表单，等等。步骤之间的切换通过改变当前页面的state来实现：State控制不同控件的显示、掩藏等。

直觉不应该这么实现，今天看了《Flex 3权威指南》 之后，终于找到了答案：ViewStack才是这种场景的正确实现方式。

State和ViewStack虽然都可以用来实现上述的场景，但使用state方式的问题在于它不是为这种场景设计的实现方式。所以，在实现过程中可能会非常痛苦。

以下是State和ViewStack的一些区别：

－－ EOF －－

PS： 我还是Flex菜鸟一个，理解不当之处请朋友们指正。

• —软件人才免语言低担保 赴美带薪读研！—

Web技术集的复制

可以说，Flex中的所有技术都是Web技术集的一次复制。如下表

此外，Flex 3开始，事件处理的机制也开始采用和DOM（JavaScript）一样的冒泡事件流机制。不过，它还可以自定义事件。

RIA的设计理念

RIA越加流行，但Flex可能不是大多数人的选择。而它的设计思想却是RIA的范本：客户端MVC。

此外，模块化等思想也值得借鉴。

桌面部署

Flex应用也可以通过AIR部署成一个桌面应用。

小结

随着HTML5和CSS3时代的迅速来临（浏览器的日益强大），Flex必将成为一个鸡肋。不知道什么时候回过头来看，它可能已湮没在历史长河中，被人遗忘。

突然想起，在此书的第一章中，介绍了多种RIA技术。其中有一段对AJAX的描述：一种尚未被淘汰的技术。

－－EOF－－

• —软件人才免语言低担保 赴美带薪读研！—

     因为data attribute刚好可以在IE使用，但这决不是说IE支持HTML5。

     有人在stackoverflow里面做了解答，具体请移步：http://stackoverflow.com/questions/2412947/do-html5-custom-data-attributes-work-in-ie-6

2. header中生成的 csrf_meta_tag 有何用？

    刚开始以为是HTML支持的新特性，能在提交的表单中自动加上它。在感叹我竟然落伍这么多的时候，突然一拍脑袋想起来，还是为了UJS嘛。

3.  表单中的hidden input: _snowman

     注意到表单中有一个hidden input：

<input name="_snowman" type="hidden" value="&#9731;" />

     这个不平凡的东西，竟然是为了这么一个普世大众都熟知的问题：IE惹得祸。

     有人还为了这个问题专门建了个网站，一个只有一个页面的网站。

     具体请移步：http://railssnowman.info/

     不过，我真的喜爱Rails 3对UTF-8的强有力支持。

初探Rails 3，发现Rails的变化和进步真的很大。但也一下子陌生了很多。

--EOF--

• —软件人才免语言低担保 赴美带薪读研！—

1. 加载根对象时如何避免加载大半个数据库

    同样，“更多的时候，这是一个建模问题”。使用eager load还是lazy load是用户的选择，根据特定场景而定。

    ActiveRecord和Hibernate一样，即可以在模型之间指定load方式，也可以在特定查询里面eager load，根据上句话，后者是更好的选择。

    Session per request, Open Session in View pattern

    Database Connection

     在非线程安全时，每个application instance都会被分配一个database connection。实现线程安全之后：

2. 存储时如何更新整个对象图

    切尔斯基已经做了解答：

3. 存储时如何高效地更新整个对象图

    答案未知。

4. 何时同步对象的内存状态和持久存储状态

    基本上在transaction commit的时候。另外reload方法也会导致内存状态和持久存储状态的更新。

5. 如何确保在出错时保持对象内存状态和持久存储状态之间的一致性

6. 如何保证引用的唯一性以避免可能的更新冲突

    这个答案跟Hibernate的实现有很大不同（至少目前，Rails2.3.6）

    ActiveRecord没有实现Identity Map。当然你要是想用，可以在这里找到一个简单实现：http://github.com/pjdavis/identity-map 。不过ActiveRecord的identity map好像已经在计划之中了。

    所以，如果两个对象持有同一个record，则互相并不会知道对方的存在。如下：

user1 = User.find(1)
user2 = User.find(1)

user1.update_attribute(:name => 'fuck')
user2.save  // 覆盖上个更新 

7. 性能优化问题

1. N+1查询问题

2. 分离查询模型和存储模型

3. 尽量减少查询语句

    关于1和3，在我的这篇文章中有详细解释：http://huzhenbo.name/blog/2010/01/16/rails-performance-tuning

8. ActiveRecord Query Cache

     ActiveRecord的query cache起到和Hibernate中的session一样的第一级缓存的作用。

Reference：

http://martinfowler.com/eaaCatalog/identityMap.html

http://takacsot.freeblog.hu/Files/martinfowler/identityMap.html

----EOF----

• —软件人才免语言低担保 赴美带薪读研！—

Ruby中的Fiber是一种semi-coroutine，第一次看到这个东西挺难理解。

Subroutine VS Coroutine

理解semi-coroutine之前先来了解下什么是coroutine，子程序（subroutine）很容易理解，通过比较能看出它们之间的区别。

Practically, yielding returns the result to the calling coroutine and gives it back control, like a usual subroutine. However, the next time the coroutine is called, the execution does not start at the beginning of the coroutine but just after the yield call.

那什么是semi-coroutine：Semi-Coroutines are asymmetric Coroutines which are limited in their choice of transfer of control. Asymmetric Coroutines can only transfer control back to their caller, where Coroutines are free to transfer control to any other Coroutine, as long as they have a handle to it.

Fiber VS Thread

Ruby的Fiber是一种控制结构（后面会说到Fiber::Core），它的运行方式和操作方法很像thread。

Fiber VS Closure

看下面这个方法：

fib = Fiber.new do
   f1 = f2 = 1
   loop do
     Fiber.yield f1 (每次resume，在遇到Fiber.yield或者block结尾时结束)
     f1, f2 = f2, f1 + f2 （第二次resume，从这里开始）
   end
end

10.times { puts fib.resume }

很容易想到用closure去实现它：

def local_proc
    f1 = f2 = 1
    return Proc.new {f1, f2 = f2, f1 + f2; p f1;}
end

proc1 = local_proc

10.times {proc1.call}

上面两个方法的实现方式是很不相同的。Fiber方式通过 enable the automatic conversion of internal iterators, such as each, to enumerator or external iterators来实现。

Fiber::Core VS Fiber

相较于Fiber，Fiber::Core是真正的coroutine -- 一种可以实现userspace thread的轻量级线程。

Ruby1.9实现了kernal threads（sometimes too heavy），所以提供一种轻量级的并行化方式是必要的。

Fiber for JRuby

实现JRuby等其它ruby实现的Fiber会遇到一些困难：

即使用workarounds，也有一些值得担心的性能问题：

用途

Coroutines are well-suited for implementing more familiar program components such as cooperative tasks , iterators , infinite lists and pipes .。

References:

coroutine: http://en.wikipedia.org/wiki/Coroutine

用Ruby的fiber实现pipe的例子：http://pragdave.blogs.pragprog.com/pragdave/2007/12/pipelines-using.html

----EOF----

• —软件人才免语言低担保 赴美带薪读研！—

Thread Safe Rails？ 关于线程安全的Rails，请大家慎重采用，具体看这篇文章：http://m.onkey.org/thread-safety-for-your-rails。

上一个项目我们怀着战战兢兢的心情开启了多线程，结果是出乎意料得好。开启多线程后没遇到什么困难，可能会遇到的问题有两点：

1. 去掉class variable (当然，基本上你不应该使用类变量)

2. 另外一件事情，就是在multiple threads下面Rails需要eager load libs。请移步：http://gigix.thoughtworkers.org/2009/7/17/move-to-multi-threaded-rails

多线程的Rails对于performance有极大提升，请再次移步：http://blog.headius.com/2008/08/qa-what-thread-safe-rails-means.html   （请自行fan qiang）

基本上意思是内存使用量的锐减和数据库连接资源的优化:

References:

教程： http://m.onkey.org/2008/10/23/thread-safety-for-your-rails

Slides:  http://www.slideshare.net/Naoto.Takai/jruby-on-rails-and-thread-safety-presentation 
Q & A: http://stackoverflow.com/questions/647642/ruby-rails-thread-safety

----EOF----

• —软件人才免语言低担保 赴美带薪读研！—

Along with the popularity of  RIA and the arrival of HTML5 in near future, JavaScript is more and more important.

Are you an eligible JavaScript programmer? Please check the following list.

Core JavaScript

1. Is JavaScript an object-oriented language or object-based language? Why?
2. What does the keyword this refer to in a method? Is there an exception for nested function? And how about the keyword this in an event handler of client JavaScript?
3. How does the JavaScript function scoped? Lexically or dynamically? What is the scope chain of a function consisted of? What are call object and global object?
4. All JavaScript functions are closures, is it true? Why?
5. What is constructor?
6. What is prototype?
7. How to simulate classes in JavaScript?
8. How to create modules and namespaces in JavaScript?

Client-Side JavaScript

1. What is global object and global execution context of client-side JavaScript? What happens when there are multiple frames in a window or when we need to interact with multiple windows?
2. What is DOM - document object model? What's the differences between legacy DOM and W3C DOM?
3. What is unobtrusive JavaScript?
4. How many ways to embed JavaScript in HTML? What are they?
5. What is the execution order of client-side JavaScript?
6. Is client-side JavaScript multi-threaded or single-threaded? How about the core JavaScript?
7. What is same-origin policy of client-side JavaScript?
8. How does client-side JavaScript deal  with event handler? What's the differences between event handlers in legacy DOM and DOM level 2?
9. How can client-side JavaScript communicate with a web server without causing web browser to reload current page? Are there any other ways besides XMLHttpRequest?
10. How to create, specify and submit HTTP request through XMLHttpRequest? How to synchronously or asynchronously retrieve the response?
11. Do you fully understand the sentence: "Ajax takes control of HTTP away from the browser itself"? What kind of user experience problems arise because of it? How to improve the user experience of Ajax-based web applications？
12. Do you know that W3C designed the DOM API to be language-neutral and focused primary on XML documents? Its use with HTML documents is through an optional extension module.
13. What can JavaScript do with client-side graphics, Java Applets and Flash movies?

原文：http://huzhenbo.name/blog/2010/04/04/to-be-an-eligible-javascript-programmer/

• —软件人才免语言低担保 赴美带薪读研！—