精品自拍视频,天天超碰亚洲,亚洲欧美一区二区三区久本道91

Add primitive Progression Enhancement support of Rails

Raimundox — Wed, 18 Mar 2009 06:38:00 GMT

Currently the concept of Progressive Enhancement is getting hotter and hotter. It emphasizes accessibility, semantic markup, and the importance of separating the complex rich interaction logic into well modularized javascript files. It's really a usefully way of thinking about how to modularize and manage web presentation components. But the Rails framework doesn't have good support for PE, so we have to define our own convention and helpers to make our life easier.

Usually, I'd like to organize js files in the Rails convention, which means we'll have something like this:

app

- views

- admin

_ new.html.erb

- index.html.erb

public

- javascripts

- admin

- new.js

- index.js

And new.js looks similar to:

$(document).ready(function() {
  enhanceInteractionOnElements();

});

function helper_methods() {

}

Then, add the follow method to ApplicationHelper module:

def page_javascript_include_tag
file = "#{params[:controller]}/#{params[:action]}.js"
File.exist?("#{RAILS_ROOT}/public/javascripts/#{file}") ? javascript_include_tag(file) : ""
end

this method will look for js file for a particular page. And in you layout file, add one line in the head sectin:

<%= page_javascript_include_tag %>

That's it. Whenever you request an action of a particular controller, it will find and include the PE js files automatically. Now we've very very primitive support of PE in Rails framework now.

Raimundox 2009-03-18 14:38 发表评论

A very brief introduction to Aurum

Raimundox — Wed, 05 Sep 2007 15:21:00 GMT

Aurum is a Ruby-based LALR(n) parser generator that you can use to develop your own domain specified languages, scripting languages and programming languages.Although it's just yet another parser generator, Aurum is slightly different from other widely used parser generators:

One of major targets of Aurum is to simplify external DSL development, espectually Ruby external DSL.
Aurum uses incremental LALR(n) algorithm instead of the common used LALR(1)/Full LALR(n) algorithm. That means:
- Allowing the user to express grammars in a more intuitive mannar.
- Making it easier to handle complicated grammars. For exmaple, COBOL(LALR(2 or 3)), simplified nature language(LALR(3+)) and etc.
- Closer to Generalized LR in language recognizing but much more faster.
- Smaller parsing table comparing to Full LALR/LR(n) algorithm.
Aurum supports grammar reuse, and itslef'll be shipped with some pre-defined common structures. One of the pain points of external DSL is that you have to re-define lots of common structures, such as if statements, block structure and etc. With Aurum, you could simply reuse them.
Aurum uses a Ruby interal DSL as meta-language, and provides a generic lexer/parser as well. You could test your grammar by the comprehensive testing libraries Ruby has(you could even develop your lexer/parser in the TDD fashion).
As the name suggested, Aurum, the Latin word for Gold, is partially inspired by the GOLD Parsing System. The grammar you created with Aurum could be completely independent of any implementation language,even Ruby.(not implemented yet :) )

Ok, let's start from the 'Hello World in Compiler Construction' —�?Expression Evaluation

1 require 'aurum'
2
3 class ExpressionGrammar < Aurum::Grammar
4   tokens do
5     ignore string(' ').one_or_more     # <= a
6     _number range(?0, ?9).one_or_more  # <= b
7   end
8
9   precedences do  # <= c
10     left '*', '/'
11     left '+', '-'
12   end
13
14   productions do # <= d
15     expression expression, '+', expression {expression.value = expression1.value + expression2.value} # <= e
16     expression expression, '-', expression {expression.value = expression1.value - expression2.value}
17     expression expression, '*', expression {expression.value = expression1.value * expression2.value}
18     expression expression, '/', expression {expression.value = expression1.value / expression2.value}
19     expression '(', expression, ')'        do expression.value = expression1.value end # <= f
20     expression _number                     {expression.value = _number.value.to_i}
21     expression '+', _number                {expression.value = _number.value.to_i}
22     expression '-', _number                {expression.value = -_number.value.to_i}
23   end
24 end

If you has any experience with other compiler compiler/parser generator, you probably could understand what happens above quite easily. Instead of explaining things like token, character class, and production, I'd like to emphasise some Aurum conventions:

At point a, we use 'ignore' directive to declare the ignored pattern, such as whitespaces etc.'string' is one of the helper methods(others are enum, range and concat), which is used to define lexical patterns. It will create a pattern matching the given string exactly.
At point b, we declare a lexical token named '_number'. In Aurum, lexical tokens, or terminals from syntax perspective, always start with '_'. The expression '_token_name pattern' is equivalent to 'match pattern, :recognized => :_toke_name'. The 'match' directive is a common way to associate lexical action with leixcal pattern.
At point c, we declare operator precedences of the Expression grammar.The eariler the operators definied, the higher precedence they will have.
At point d, we declare syntax rules of Expression grammar. According to Aurum naming convention, all terminals should start with '_' while all nontermainls start with lower case alphabet character. String literals will be interpreted as reserve words, and added to lexer automatically.
At point e, we define a semantic action to the Addition rule. In semantic action, you could access to the objects in value stack via the name of corresponding symbols.If there are more than one symbol with the same name, you could differentiate them by the order they appered in the production.
At point f, we use do..end instead of {..}. Using Ruby internal DSL as meta-langauge is a double-side sword, you have to bear its flaws while enjoying the remaining parts. There is no perfect world, isn't it?

Now, let's find out how we could use this expression grammar. You could use the helper method as below(it will recalcuate lexical table and parsing table for every call, could be quite slow):

1 puts ExpressionGrammar.parse_expression('1+1').value

or use the lexical table and parsing table to create your own lexer & parser:

1   lexer = Aurum::Engine::Lexer.new(ExpressionGrammar.lexical_table, '1+1')
2   parser = Aurum::Engine::Parser.new(ExpressionGrammar.parsing_table(:expression))
3   puts parser.parse(lexer).value

At the end of this post, I'd like to give another grammar example coming from Martin Fowler's HelloParserGenerator series:

1 require 'aurum'
2
3 Item = Struct.new(:name)
4
5 class Catalog < Aurum::Grammar
6   tokens do
7     ignore enum(" \r\n").one_or_more
8     _item range(?a,?z).one_or_more
9   end
10
11   productions do
12     configuration configuration, item {configuration.value = configuration1.value.merge({item.value.name => item.value})}
13     configuration _                   {configuration.value = {}}
14     item 'item', _item                {item.value = Item.new(_item.value)}
15   end
16 end
17
18 config = Catalog.parse_configuration(<<EndOfDSL).value
19   item camera
20   item laser
21 EndOfDSL
22
23 puts config['camera'].name

P.S.:The post is based on the developing version of Aurum(0.2.0). You could get it from the svn repository.
P.S.P.S.: There is a more complicated example in the examples directory, a simple Smalltalk interpreter. Have fun:)

Raimundox 2007-09-05 23:21 发表评论

A very brief introduction to Aurum

Raimundox — Wed, 05 Sep 2007 15:12:00 GMT

A very brief introduction to Aurum

Aurum是一个用Ruby实现的LALR(n) parser generator�Q�是的，又是一个parser generator�Q�，不过它和其他一些广泛应用的parser generator相比略有不同的：

1.Aurum的主要目标之一�Q�是��化external DSL的开发（��其是ruby external DSL�Q��?br /> 2.Aurum采用增量LALR(n)��法�Q�而不是通常的LALR(1)。这意味着�Q?br /> a.不必�׃��LALR(1)能力的限�Ӟ��而改写语法，很多在LALR(1)中冲�H�的语法在LALR(n)中可以比较自然地表达�?br /> b.�׃��识别能力的增强，可以处理一些比较复杂的语法�Q�比如COBOL(LALR(2)或LALR(3))�Q�比如一些简化的自然语言(LALR(3+))�?br /> c.处理能力接近Generalized LR�Q�却快很�?br /> d.比�vFull LALR/LR(n)�Q�增量算法生成的语法表更��?br /> 3.��Z��化external DSL实现的考虑�Q�Aurum支持语法重用�?br /> 4.Aurum采用Ruby internal DSL作�ؓ语法声明的元语言�Q�可以利用Ruby丰富的测试框�Ӟ��有效地对�~�译�Q�解释／分析器进行测试�?br /> 5.正如名字所暗示的，Aurum�Q�Gold的化学名�U�ͼ�的一部分灉|��来自GOLD parsing system�Q�它��支持独立于�q�_��和语�a�的编译器开发�?br />
好，闲话��说�Q�看一个例子，�~�译原理中的Hello World —�?表达式求��|��

如果�怽�对之前有用过compiler compiler或者parser generator的话�Q�应该能看个七七八八吧。我大概解释一下：
a.�q�里定义了文法空白，也就是被lexer忽略的部分，在通常的语�a�中，是空格回车换行之�cȝ��字符�Q�string是用于定义lexical pattern的helper�Ҏ��Q�出了string之外�Q�还有range, enum和concat�Q�；ignore是一个预定义的说明指令，表示若文本匹配给定模式则该文本会被lexer自动忽略�Q�其格式为：
    ignore pattern {//lexical action}
b.此处为lexical token声明�Q�所有lexical token必须以_开��_��其格式�ؓ�Q?br />     _token_name pattern {//lexical action}
   �q�里其实是一个简略写法，�{��h�?br />     match pattern, :recognize => �Q�_token_name
c.此处��符优先�U�声明，支持�?右结合运��符�Q�无�l�合属性运��符开发中�Q�；每一行中所有运��符��h��相同优先�U�；比它下一行的�q�算�W�高一个优先��。比如在�q�个例子中，'*'�?/'��h��相同优先�U�，但是�?+'�?-'的优先��别高�?br /> d.此处��法规则声明，所使用的symbol主要有三�U�，nonterminal(��写字母开�?�Q�terminal(其实��是lexical token�Q�以_开�?和literal(字符串常�?�Q�其中所有literal都会被自动声明�ؓ保留字�?br /> e.此处定义了一条文法规则（加法�Q�，以及对应的semantic action。在semantic action中可以直接通过symbol的名字来获取值栈中的对象。如遇到同名symbol�Q�则按照出现��序�q�行�~�号卛_��?br /> f.其实�q�个没啥�Q�只不过�׃��我们使用的是Ruby DSL�Q�所以有时候不能都用{}�Q�需要do end�Q�这��是一个例子�?br />
最后测试一下实际中如何使用定义好的语法�Q��用helper method�Q�注意由于分析表没有�~�存�Q�每�ơ都会重��语法表�Q�仅仅适用于debug mode。）
puts ExpressionGrammar.parse_expression('1+1').value
或者通过分析表自己构造lexer和parser
lexer = Aurum::Engine::Lexer.new(ExpressionGrammar.lexical_table, '1+1')
parser = Aurum::Engine::Parser.new(ExpressionGrammar.parsing_table(:expression))
puts parser.parse(lexer).value

最后最后，�l�另外一个例子，��是Martin Fowler Blog上的HelloParserGenerator�p�d��中所用的语法�Q?br />

P.S.:本文是根据Aurum0.2.0写成的，你可以从rubyforge的svn上得到它�?br /> P.S.P.S.: 在exmaples目录里有一个更复杂一些的例子�Q�是一个简单的Smalltalk解释器�?br />

Raimundox 2007-09-05 23:12 发表评论

Erlang Ring Benchmark

Raimundox — Wed, 01 Aug 2007 12:34:00 GMT

《Programming Erlang》第8章后面有一个练习，Ring Benchmark。就是说创徏N个进�E�，把它们组合成环状。然后在�q�个环上把一条消息在环上传递M圈，然后记录所有的旉��。实现�v来也挺简单，20行左叛_��Q?br>

1 -module(ring_benchmark).
2 -export([start/2]).
3
4 start(N, M) ->
5   Pid = create_process(self(), N - 1, M),
6   time(fun() -> Pid ! start, loop(Pid, M) end).
7
8 time(Fun) ->
9   statistics(wall_clock),
10   Fun(),
11   {_,Time} = statistics(wall_clock),
12   io:format("Run : ~w s ~n", [Time/1000]).
13
14 create_process(Pid, 0, _) -> Pid;
15 create_process(Pid, N, M) -> create_process(spawn(fun() -> loop(Pid, M) end),  N - 1, M).
16
17 loop(_, 0) -> void;
18 loop(Next, M) ->
19   receive
20     Message -> Next ! Message,
21     loop(Next, M - 1)
22   end.
23
24

有意思是它还有一个第二问�Q�让你用另外一�U�熟悉的语言实现同样的功能，发送同样多的消息，也把旉��记录下来�Q�然后写一��blog来publish你的�l�果。其实，大家心知肚明�Q�这�U�lightweight process啊，message passing concurrency啊都是Erlang的强��，而且实测�l�果也着实颇为恐怖，一般也��没那闲心拿别的东西来陪衬一把了�Q�Armstrong同学自己实现了一个Java version�Q�效率大�U�能差到癑ր�吧�Q�。不�q�还真有那写不信邪的老大�Q?a >用stackless python实现了同��L��ring benchmark�Q�发现比erlang�q�快...后来修改代码��L��io操作�Q�Erlang倒是比stackless python快些�Q�但也只是一些而已�?br>

Raimundox 2007-08-01 20:34 发表评论

Domain Oriented Web Testing with Selenium & Ruby (Posted@InfoQ China)

Raimundox — Wed, 13 Jun 2007 01:44:00 GMT

http://www.infoq.com/cn/articles/domain-web-testing

应用Selenium�q�行Web��试往往会存在几个bad smell�Q?br>1.大量使用name, id, xpath�{�页面元素。无论是功能修改、UI重构�q�是交互性改�q�都会媄响到�q�些元素�Q�这使得Selenium��试变得非常脆弱�?br>2.�q�于�l�节的页面操作不�Ҏ��体现��为的意图�Q�一�D�|��间之后就很难真正把握��试原有的目的了�Q�这使得Selenium��试变得难于�l�护�?br>3.对具体数据取值的存在依赖�Q�当个别数据不再合法的时候，��试��׃��p�|�Q�但�q�样的失败�ƈ不能标识功能的缺失，�q��得Selenium��试变得脆弱且难以维护�?br>
而这几点直接衍生的结果就是不断地��d��新的��试�Q�而极��地去重构、利用原有测试。其实这��C��是正常，单元��试��试写多了，也有会有�q�样的问题。不�q�比较要命的是，Selenium的执行速度比较慢（相对单元��试�Q�，随着��试逐渐的增多，�q�行旉��会逐渐增加��C��可忍受的�E�度。一�l�意图不明难以维护的Selenium��试�Q�可以很��L��地在每次build的时候杀�?0分钟甚至2个小时的旉��Q�在下就有花2个小时坐在电脑前面等�?50个Selenium��试�q�行通过的悲惨经历。因此合理有效地规划Selenium��试��显得格外的�q�切和重要了。而目前比较行之有效的办法�Q�往大了��_��可以叫domain based web testing�Q�具体来�Ԍ��是Page Object Pattern�?br>
Page Object Pattern里有四个基本概念�Q�Driver, Page, Navigator和Shortcut。Driver是测试真正的实现机制�Q�比如Selenium�Q�比如Watir�Q�比如HttpUnit。它们懂得如何去真正执行一个web行�ؓ�Q�通常包含像click�Q�select�Q�type�q�样的表�C�具体行为的�Ҏ��Q�Page是对一个具体页面的��装�Q�它们了解页面的�l�构�Q�知道诸如id�Q?name�Q?class�Q�xpath�q�类实现�l�节�Q��ƈ描述用户可以在其上进行何�U�操作；Navigator则代表了URL�Q�表�C�Z��些不�l�页面操作的直接跌��{�Q�最后Shortcut��是helper�Ҏ��了，需要看具体的需要了。下面来看一个超�U�简单的例子——测试登录页面�?br>
1. Page Object

假设我们使用一个单独的Login Page�q�行��d��Q�那么我们可能会��登录的操作��装在一个名为LoginPage的page object里：

1 class LoginPage
2   def initialize driver
3     @driver = driver
4   end
5
6   def login_as user
7     @driver.type 'id=', user[:name]
8     @driver.type 'xpath=', user[:password]
9     @driver.click 'name='
10     @driver.wait_for_page_to_load
11   end
12 end

login_as是一个具有业务含义的��面行�ؓ。在login_as�Ҏ��中，page object负责通过依靠id�Q�xpath�Q�name�{�信息完成登录操作。在��试中，我们可以�q�样来��用这个page object�Q?br>

1 page = LoginPage.new $selenium
2 page.login_as :name => 'xxx', :password => 'xxx'
3

不过既然用了ruby�Q�总要用一些ruby sugar吧，我们定义一个on�Ҏ��来表��N��面操作的环境�Q?br>

1 def on page_type, &block
2 page = page_type.new $selenium
3 page.instance_eval &block if block_given?
4 end

之后我们��可以��用page object的类名常量和block描述在某个特定页面上操作了：

1 on LoginPage do
2 login_as :name => 'xxx', :password => 'xxx'
3 end
4

除了行�ؓ�Ҏ��之外�Q�我们还需要在page object上定义一些获取页面信息的�Ҏ��Q�比如获取登录页面的�Ƣ迎词的�Ҏ��Q?br>

def welcome_message
@driver.get_text 'xpath='
end

�q�样��试也可表达得更生动一些：

1 on LoginPage do
2 assert_equal 'Welcome!', welcome_message
3 login_as :name => 'xxx', :password => 'xxx'
4 end

当你把所有的��面都用Page Object��装了之后，��有效地分离了测试和��面�l�构的耦合。在��试中，只需使用诸如login_as, add_product_to_cart�q�样的业务行为，而不必依靠像id�Q�name�q�些具体且易变的��面元素了。当�q�些��面元素发生变化�Ӟ��只需修改相应的page object��可以了�Q�而原有测试基本不需要太大或太多的改动�?br>
2. Assertation

只有行�ؓ�q�够不成��试�Q�我们还要判断行为结果，�q�进行一些断�a�。简单回��一下上面的例子�Q�会发现�q�有一些很重要的问题没有解冻I��我怎么判断��d��成功了呢�Q�我如何才能知道真的是处在登录页面了呢？如果我调用下面的代码会怎样呢？

1 $selenium.open url_of_any_page_but_not_login
2 on LoginPage {}

因此我们�q�需要向page object增加一些断�a�性方法。至��，每个��面都应该有一个方法用于判断是否真正地辑ֈ�了这个页面，如果不处在这个页面中的话�Q�就不能�q�行��M��的业务行为。下面修改LoginPage使之包含�q�样一个方法：

1 LoginPage.class_eval do
2   include Test::Unit::Asseration
3   def visible?
4     @driver.is_text_present() && @driver.get_location ==
5   end
6 end

在visible?�Ҏ��中，我们通过对一些特定的��面元素�Q�比如URL地址�Q�特定的UI�l�构或元素）�q�行判断�Q�从而可以得之是否真正地处在某个��面上。而我们目前表达测试的基本�l�构是由on�Ҏ��来完成，我们也就��理成章地在on�Ҏ��中增加一个断�a��Q�来判断是否真的处在某个��面上，如果不处在这个页面则不进行�Q何的业务操作�Q?br>

1 def on page_type, &block
2   page = page_type.new $selenium
3   assert page.visible?, "not on #{page_type}"
4   page.instance_eval &block if block_given?
5   page
6 end
7

�q�个�Ҏ��秘地返回了page对象�Q�这里是一个比较tricky的技巧。实际上�Q�我们只惛_��用page != nil�q�个事实来断�a��面的流转，比如�Q�下面的代码描述��d��成功的页面流转过�E�：

on LoginPage do
assert_equal 'Welcome!', welcome_message
login_as :name => 'xxx', :password => 'xxx'
end
assert on WelcomeRegisteredUserPage

除了�q�个基本断言之外�Q�我们还可以定义一些业务相关的断言�Q�比如在购物车页面里�Q�我们可以定义一个判断购物�R是否为空的断�a��Q?br>

1 def cart_empty?
2 @driver.get_text('xpath=') == 'Shopping Cart(0)'
3 end

需要注意的是，虽然我们在page object里引入了Test::Unit::Asseration模块�Q�但是�ƈ没有在断�a��Ҏ��里��用�Q何assert*�Ҏ��。这是因为，概念上来讲page object�q�不是测试。��之包含一些真正的断言�Q�一则概忉|؜乱，二则�Ҏ��使page object变成针对某些场景的test helper�Q�不利于以后��试的维护，因此我们往往們֐�于将断言�Ҏ��实现��Z��个普通的�q�回��gؓboolean的方法�?br>
3. Test Data

��试意图的体��C��仅仅是在行�ؓ的描�q�C��Q�同栯��有测试数据，比如如下两段代码�Q?br>

1 on LoginPage do
2 login_as :name => 'userA', :password => 'password'
3 end
4 assert on WelcomeRegisteredUserPage
5
6 registered_user = {:name => 'userA', :password => 'password'}
7 on LoginPage do
8 login_as registered_user
9 end
10 assert on WelcomeRegisteredUserPage

��试的是同一个东西，但是昄��W�二个测试更好的体现了测试意图：使用一个已注册的用��L��录，应该�q�入�Ƣ迎��面。我们看�q�个��试的时候，往往不会兛_��用户名啊密码啊具体是什么，我们兛_��它们表达了怎样的测试案例。我们可以通过DataFixture来实现这一点：

1 module DataFixture
2   USER_A = {:name => 'userA', :password => 'password'}
3   USER_B = {:name => 'userB', :password => 'password'}
4
5   def get_user identifier
6     case identifier
7     when :registered then return USER_A
8     when :not_registered then return USER_B
9     end
10   end
11 end

在这里，我们��测试案例和具体数据做了一个对应：userA是注册过的用��P��而userB是没注册的用戗��当有一天，我们需要将��d��用户名改为邮��q��时候，只需要修改DataFixture模块��可以了�Q�而不必修改相应的��试�Q?br>

1 include DataFixtureDat
2
3 user = get_user :registered
4 on LoginPage do
5 login_as user
6 end
7 assert on WelcomeRegisteredUserPage

当然�Q�在更复杂的��试中，DataFixture同样可以使用真实的数据库或是Rails Fixture来完成这��L��对应�Q�但是��M��的目的就是�ɋ��试和测试数据有效性的耦合分离�Q?br>

1 def get_user identifier
2   case identifier
3   when :registered then return User.find '.'
4   end
5 end

4.Navigator

与界面元素类��|��URL也是一�c�L��变且难以表达意图的元素，因此我们可以使用Navigator使之与测试解耦。具体做法和Test Data�怼��Q�这里就不赘�q�C��Q�下面是一个例子：

1 navigate_to detail_page_for @product
2 on ProductDetailPage do
3 .
4 end

5. Shortcut

前面我们已经有了一个很好的基础�Q�将Selenium��试与各�U�脆�׃��意图不明的元素分��d��了，那么最后shortcut不过是在蛋糕上面最漂亮的奶油�Ş了——定义具有漂亮语法的helper�Q?br>

1 def should_login_successfully user
2   on LoginPage do
3     assert_equal 'Welcome!', welcome_message
4     login_as user
5   end
6   assert on WelcomeRegisteredUserPage
7 end

然后是另外一个magic�Ҏ��Q?br>

1 def given identifer
2 words = identifier.to_s.split '_'
3 eval "get_#{words.last} :#{words[0..-2].join '_'}"
4 end

之前的测试就可以被改写�ؓ�Q?br>

def test_should_xxxx
should_login_successfully given :registered_user
end

�q�是一�U�结论性的shortcut描述�Q�我们还可以有更behaviour的写法：

1 def login_on page_type
2   on page_type do
3     assert_equal 'Welcome!', welcome_message
4     login_as @user
5   end
6 end
7
8 def login_successfully
9   on WelcomeRegisteredUserPage
10 end
11
12 def given identifer
13   words = identifier.to_s.split '_'
14   eval "@#{words.last} = get_#{words.last} :#{words[0..-2].join '_'}"
15 end

最后，��试��׃��变成�c�M��验收条�g的样子：

1 def test_should_xxx
2   given :registered_user
3   login_on LoginPage
4   assert login_successfully
5 end

��M��shortcut是一个无兛_��坏，只关乎想象力的东西，��情挥洒Ruby DSL�?D

�l�论

Selenium是一个让人又爱又恨的东西�Q�错误地使用Selenium会给整个敏捷团队的开发节奏带来灾难性的影响。不�q�值得庆幸的是正确��C��用Selenium的原则也是相当的��单：

1.通过��脆弱易变的��面元素和测试分��d��Q��得页面的变化不会�Ҏ��试��生太大的影响�?br>2.明确指定��试数据的意图，不在��试用��用�Q何具体的数据�?br>3.��一切可能，明确地表辑և��试的意图，使测试易于理解�?br>
当然�Q�除了遵循这几个基本原则之外�Q��用page object或其他domain based web testing技术是个不错的选择。它们将会帮助你更容易地控制Selenium��试的规模，更好地��^衡覆盖率和执行效率，从而更加有效地交付高质量的Web��目�?br>
鸣谢

此文中涉及的都是我最�q�三周以来对Selenium��试�q�行重构时所采用的真实技术。感谢Nick Drew帮助我清晰地划分了Driver, Page, Nagivator和Shortcut的层�ơ关�p�，它们构成我整个实�늚�基石�Q�感谢Chris Leishman�Q�在和他pairing programming的过�E�中�Q�他帮助我锤��g��Ruby DSL�Q�还有Mark Ryall和Abhi�Q�是他们�W�一�ơ在��目中引入了Test Data Fixture�Q��得所有�h的工作都变得��单�v来�?br>

Raimundox 2007-06-13 09:44 发表评论

I'm Smalltalk, Which Programming Language are You?

Raimundox — Wed, 02 May 2007 09:48:00 GMT

Which Programming Language are You?

p.s. �q�个可能不准...因�ؓ李默同学竟然是Lisp...怎么可能...

Raimundox 2007-05-02 17:48 发表评论

X-Files

Raimundox — Fri, 30 Mar 2007 14:52:00 GMT

刚才和李默同学回忆了一下，发现我自从入行以来做了很多x��目...下面一一列�D一下�?br />
1. IEC61970 Metadata: Electricity Power Trading System

当时刚上班，team里有一个Doamin知识很厉害的清华的博士，毕业的论文就是电力市场，而清华又是国家引入IEC61970的五家之一。所以他很超前的把这两个东西�l�合在一��P��做成了一个系�l�。说实话�Q�刚了解IEC61970的时候，我是相当的震撼的�Q�有赶上那时候MDA风气刚�v�Q�IEC61970又是同时MOF(Meta Object Facility)和RDF based�Q�华丽得不行。一下子我就变成了一个MDA guy�Q�一个metadata guy...以至于，在BJUG最初的2�q�里�Q�MDA/MOF/Metadata成�ؓ了主旋律...

2. IEC61970 & CWM(Common Warehouse Metamodel) & Office Plugin : Data Warehouse Integration System

�q�是�q�今为止�Q�我最不愿意回忆的一个项�?..因�ؓOffice Plugin...动辄蓝屏的遭遇让我心有余�?..�q�是一个backend是J2EE�Q�frontend�?Net的office插�g�pȝ��Q�主要是报表...两边都��用CWM作�ؓ数据�l�一的�Ş�?..基本上做��C��半我的意志就崩溃�?..

3. DB Migration/Refactoring : Jyxpearl

�q�个��目...是李默同学的�U�房最爱，从大学一直做了很久，改版无数��?..当时没有�q�么��行的好词，什么DB Migration啊，DB Refactoring啊，那时候我们统�U�导数据...我导了好多会...基本上线一回导一�?..时至今日...李默同学��L��不无得意的说�Q�你看，你DB Migration的能力就是我培养�?..

4. JMI(Java Metadata Interface) & Eclipse RCP : Multi/Rich Client ERP Product

�q�个team其实挺华丽的�Q�老栾的��品经理，李默是开发经理，��资深行业专家(人家实际做过生��U�长�Q�MRPII�Q�ERP都是人家玩剩下的)老齐做需求，俺是Architect�Q�还有动物园里的猪Senior Dev�Q�我认识��Z��工能力�W�一交互设计能力�W�一的米�c�_��做UI和交互。由于当时看了netbeans和sun的官方JMI实现得太玩具。我们决定从自己的JMI实现开始，�pȝ��l�构要求多客��L��Q�web�Q�rcp都要...所以是��轻http协议的b/s�Q�c/s。结构还是不错的�Q�过�E�李默和我当然是敏捷了。似乎一起都��完美的时候，��是要坏菜的时�?..企业事业部解散了...

5. Java Communication & Eclipse RCP : IC Card Reader

上面那个��目解散之后�Q�我跟李默赋闲在�Ӟ��有不忍心打扰政府�Q�自谋生路找的项�?..�q�个��目要用IC卡读卡器�Q��ؓ了锻炼我们的Eclipse RCP能力�Q�我们决定用eclipse rcp来做。于是问题就出来�?..IC卡怎么办？google一把发现天无绝��Z��?..Java有一个Communication包，可以�q�接serial port...不过当时tricky的是...我的本子没有串口�Q�我们买了一个串口到usb的�{换器...发现�Ҏ��不能�?..于是只好跑到李默家用他华丽的台式机（�q�厮当年誓言旦旦的说�Q�laptop太慢�Q�一定要用台式机�Q�东借西借搞了个2G RAM SATA�Q�L��意，�q�是伏笔�Q�的机器�Q�。我当时��p��得，Java的这个东西基本就是充数的�Q�貌似完全没有�h用过�Q�文档啥的都特少...只能自己摸烦。在�l�历了无数次��p�|之后�Q�终于成功了。在showcase那天的上午，我最后实验了��d��什么的�Q�都没问题。兴高采烈的把jar拷到优盘上，刚插到usb口上...只见一道闪�?..机器黑了...据李默后来分析是��L��烧了...我说没事�Q�拿上硬盘，土一点也不媄响showcase。李默说...�q�个...SATA�?..�q�不��行�?..我绿...此后很长旉��Q�我都怀疑是我跟李默同学范冲�Q�超�U�项目杀�?..

6. RDF, Semantic Web, SparQL : Ontology-Relationship DB Mapping

�q�是在一家公司做产品�Q�当时我元数�?MDA领域颇有�U�篏...跟这家公司做得类��|��p��来负责研发本体到关系数据库的映射...兼带在D2RQ的基��上实��C��个SparQL查询语言。怎么�?..听上��d��华丽�?..到现在我都认为，�q�个��目是我最有潜力的牛皮�Q�不定那天web x.0了，我也老了�Q�我��可以拉着��朋友的手去吹牛b�?05�q�我��做semantic web,O/R mapping知道不？Ontology啊，你们啊，sometime too simple"...不过估计�q�一天还早得很呢

7. Agile Domain Specified Language : Goodhope

�q�个也是李默同学有䆾的项�?..话里的敏捷DSL实践...不过说实话，也有点X...

Raimundox 2007-03-30 22:52 发表评论

Agile 101: CoC & Why Agile is Hard

Raimundox — Thu, 29 Mar 2007 22:53:00 GMT

我常常听到这��L��观点�Q�敏捯��Y件开发�ƈ不是真正的革命性的�Ҏ��Q�它所采用的技术大多都是古已有之的。比如�P代，你看很哪本��Y件工�E�的教科书上没有提到�q�代开发呢�Q�在比如说User Story�Q�看上去也不只不�q�是Use Case的翻版而已吧！甚至我看RUP也和敏捷�Ҏ��没有太大的区别吧�Q?br />要我��_��q�些��么是不真的了解敏捷开发，没有认识到敏捷开发的革命性，只是用外在的形式来把它和其他�Ҏ��q�行了比较。有又或者是实施敏捷�Ҏ��的时候不��d��Q�所以四处碰壁以至于搞�v了修正主义。最可怕的��是某些大公司，看敏��L��了，��L��包装一下，到底�q�是要卖产品。敏捯��Y件开发就是一个革命性的�Ҏ��Q�只不过它要颠覆的不仅仅是低质量的��Y件开发方式，更重要的是，它要颠覆软�g生��企业和��Y件的使用企业之间的生产关�p�！!�q�一点在敏捷宣言里写得再明白不过�?br />
Customer collaboration over Contract negotiation

敏捷软�g开发，��是要以一�U�更合理的共赢的合作关系�Q�代替以前畸形的采购式的合约关系。�ؓ什么合�U�关�p�d��是畸形的�Q�我们来看看合约双方的处境�?br />
首先软�g团队斚w��承担了过多的风险�Q�业务变化，改代码！�Q�商业抉择�{换，改代码！�Q�凭啥你甲方的缘故非要我承担额外的成本？你说我冤不冤�Q�冤�Q�但是�h家甲方也冤！�Q��h家花了大把的银子�Q�拿��C��堆不能用的��Y�Ӟ��你要是硬件�h家还能�{手卖炚w��Q�，��像你要砍树别�h�l�你把铲子，你要�U�树人家�l�了你把锯。搁你，你也不愿意。且不说博弈�Q�就��双斚w��有心把事情做好，按合同来�Q�甲方不�qԌ��不按合同来，乙方不干�Q�最后变成“有心杀贼无力回天”，大家一��h��扯皮�{�二期算了。lose-lose�Q�没有赢家�?br />
那么合作的关�p�L��什么呢�Q�合作的关系��好比你去subway��C��明治�Q�面包你自己选，要什么肉你来挑，蔬菜�Q�cheese�Q�酱汁你也自��q��着办。技术我来，口味你选。技术失败我负责�Q�口味不合适你负责。你做你的强��Ҏ��来我的强��，最�l�大安��高兴兴嘻��d��哈不吵不闹，作出一��可口午��。这是时候，生��关系变了�Q�我不是你的冷冰冰的供应商，你也不是我邪恶的客户�Q�我们是拴在一根��子上的蚂蚱。成功是我们的，��p�|也是我们的。荣�׃��共，携手�q�肩。听着有点耳熟�Q�没错，SaaS。敏捷宣�a�早就说了�Q�CoC啊。从供应商变成服务商�Q�从服务商变成战略合作伙��_��q�是在给软�g企业指出路，新的生��关系已经��在其中了�?br />
如果看不清敏��L��q�个�Ҏ��革命点，以�ؓ�q�是开发方法的��打��闹�Q�那么敏��h��本实施不成。这话一般我不敢说的�Q�程序员自发实施敏捷�Q�只在一�U�情况下可能成功�Q�大企业的IT部门。再赶上个强力的IT领导�Q�自家�h嘛，有什么不好谈的。一来二去，��成功了�Q�看看C3�Q�说白了不就是IT部门和业务部门？�Q�但是，如果是做��目的公司，你营销手段不改变，敏捷��׃��可能成功。你的客戯��你不是合作关�p�，你通过敏捷增加质量�Q�符合性质量）的工作就不会被�h可，那么��׃��能成为投资，只能是成本。当成本增加��C��可承担的时候，敏捷��׃��了了之了。�ؓ什么好多�h说老板没有响应�Q�旧的生产关�p�M��敏捷�Ҏ��是负担�?br />
说道�q�里�Q�说一下以敏捷��d��的ThoughtWorks。其实很多�h都以为ThougtWorks只有�Ҏ��论咨询，没错我们是有�Ҏ��论咨询，但是也有业务模式咨询�Q�客户业务模式不改变�Q�他怎么能彻底敏��P��q�点大家不可不查啊�?img src ="http://www.aygfsteel.com/raimundox/aggbug/107375.html" width = "1" height = "1" />

Raimundox 2007-03-30 06:53 发表评论

Scripts Amuse Myself: Poor Man's Lava for CruiseControl.rb

Raimundox — Thu, 29 Mar 2007 00:53:00 GMT

Yesterday I found a interesting ruby library ——�? blinkenlights, which enables you to control the LEDs on your keyboard. I thouhgt it could be a cheap replacement of lava light, so I wrote a ruby script called 'Poor Man's Lava'

#!/usr/local/bin/ruby
require 'rss/1.0'
require 'rss/2.0'
require 'open-uri'
require 'rubygems'
require 'blinkenlights'

SUCCESS = 'success'

def read_rss source='http://cruisecontrolrb.thoughtworks.com/projects/CruiseControl.rss'
content = ''
open(source) do |s| content = s.read end
rss = RSS::Parser.parse content, false
rss.items[0].title.include?(SUCCESS) ? all_ok : alarm
end

def all_ok times = 50
BlinkenLights.open { |lights| times.times {lights.random} }
end

def alarm times = 50, invertal = 0.0
BlinkenLights.open { |lights| times.times {lights.flash invertal} }
end

while true
read_rss
sleep 5
end

make sure to have sufficient permissions to access the device, or you could simple run it as super user.

Raimundox 2007-03-29 08:53 发表评论

Agile 101: User Story & Prioritization

Raimundox — Wed, 28 Mar 2007 01:59:00 GMT

通常��Z��会将User Story和Use Case攑֜�一��h��较，虽然二者在形式上具有一定相似性，但是�I�其本质来说�Q�还是天渊之别的。这一点，专业BA李默同学�ȝ��的格外准��：“用��h��事是可见的商业�h��|��而不是功能描�q�”。想要更好的理解�q�句话，需要了解什么是好的用户故事。好的用��h��事，可用INVEST原则来概括：

I - Independent
N - Negotiable
V - Valuable
E - Estimable
S - Small
T - Testable

我个��得，�q�个�ȝ��虽好�Q�但不免分散注意。要我说�Q�想把握好User Story�Q�只用把握两个就够了Negotiable和Valuable。那么首先要��定什么是Negotiable的。User Story有一个流传广泛的书写形式�Q?br />
As , I'd like to , so that .

��Z��更好的获取story�q�有很多最佛_��践，比如personas, 比如business process modeling�Q�其实这些全是糖衣炮弹，As, I'd like to都是噱头�Q�就是�ؓ了把用户忽悠晕了�Q�然后图�I�匕现直取商业�h值和目标。一旦商业�h值确定下来，role, action都是可以negotiable。比如李默之前在文章里�D的用��L��录的例子�Q�输不输用户明密码？可以商量嘛！是不是只有注册用户可以��n受个性服务？可以商量嘛！关键是用��h��要什么，至于怎么实现�q�些到头来都是可以商量的�Q�都是Negotiable。只有客��L��商业价值是不能商量的，也没的商量。�h值没有了�Q�目标不存在了，�q�个User Story也就没用了，商量啥？重写一张就好了�?br />
因此user story又有另外一个名�U�ͼ�叫requirement placeholder。就是客户�h值的"立此存照"。至于具体需求，那么��到iteration plan meeting上是商量吧，看看当时什么样的�Ş式（功能�Q�才是最�W�合用户需要。到此，其实大家可以看出来了�Q�user story重点��׃��再How上，而是在Why上的。有了why�Q�且可Negotiable�Q�把握了�_��Q�你��是按用例来写需求又有何妨涅�Q?br />
有了valuable和negotiable的想法垫底，在看看基于user story的初步计划制定——也��是有名的prioritization——就�Ҏ��理解多了。用��h��据每张卡的�h��|��自行比较作出军_��Q�大体场景就跟向��仙许愿一栗��?br />
��仙�Q�我可以满��你一个愿望�?br />我：我要荣华富贵�Q�！�Q?br />��仙�Q�哦�Q�荣华富贵，那么要不要爱情涅�Q?br />我：恩，�q�个...那我要忠贞的爱情好了�Q�！
��仙�Q�哦�Q�忠贞的爱情�Q�那么要不要健康�q�_��呢？
我：�?...
repeat 无数�ơ，最�l�我要了一件过冬的皮猴...

Raimundox 2007-03-28 09:59 发表评论

Raimundox — Wed, 28 Mar 2007 00:29:00 GMT

自从��C��ThouhgtWorks�Q�我订阅的rss��来��少�Q�很多程度上来说�Q�有了自家的Planet TW�Q�很多相看的blog可以一�ơ性看全了�Q�没啥太大的必要�ȝ��其他的了。这不，在订阅了Planet TW后的两年中，我只增订了一�Ӟ��InfoQ。呵呵，想不到如今中文站也来�?a target="_blank">http://www.infoq.com/cn/。不错不错�?br />

Raimundox 2007-03-28 08:29 发表评论

Agile 101: Pair Programming & Simple Design

Raimundox — Tue, 27 Mar 2007 06:52:00 GMT

pair programing是所有XP实践中争议最大的一个，但窃以�ؓ��实XP实施的关键关键实践之一�Q�甚至于�Q�我认�ؓ很多XP实施的失败都是由于没有采用pair programming而造成的�?br />要了解pair��Z��么重要，��p��了解pair的目的在何。当然了�Q�大多数人都知道pair的重点在于知识传递，知识�׃�n�Q�持�l�走查，降低代码�~�陷�{�等�{�等。这些都是pair的优点，不过最重要的一点却常常被忽略——pair programing的最直接而又最�Ҏ��的目的之一在于simple design�?br />

上图是著名的Ron Jefferies Model�Q�可以看到XP最佛_��践被划分成了一个一个的圆圈�Q�而pair, TDD, refactor和simple design位于中心。这�q�不是说�q�四个实践就是xp的核心。jefferies model每一圈代表了xp实践�q�程中的不同��x��点，最中心的是dev视角�Q�其�ơ是team视角�Q�最外层是交付／��理视角。每圈上的最��x��间多��都有些紧耦合�Q�放开其他的不�Ԍ��我们专门说说dev圈，pair programing, tdd, refactor和simple design�?br />
�q�四个实践里只有simple design最虚也最重要。有一个问题已�l�被问过无数�ơ了�Q�“到底多simple的design才叫simple”。我�Ҏ��也有一个近乎刻板的回答�Q�team里所有�h员都能够理解的design��是simple的。一旦立了标准，�q�四个实�늚��M��关系��׃��下子清晰��h��——simple design是这四个实践的核心，其他三个实践都是它服务的�?br />
首先做出一个设计，最��单的判断标准��是是否可测�Q�一个不可测的设计基本上可以认�ؓ无法实现�Q�于是TDD��x��simple design的质量保证又是simple design的直觉验证�?br />
refactor是�ؓ了得到好的代码，那么什么是好的代码�Q�simple design!!!�q�里有�h不同意了�Q�有��只是要易于修改和扩展�Q�可是扩展和修改也要别�h看得懂才行啊...simple design是�v码的要求嘛。实际上�Q�XP中的refactor��是朝着simple design的方向重构过�ȝ��Q�也��是朝着所有�h都能理解的代码refactor�q�去的。插一句题外话�Q��ؓ啥说好的架构的不是设计出来的呢？因�ؓ好的架构臛_��应该是simple design的，而simple的概忉|��和�h员相�?..所以当你极��能事show off你的pattern知识之后�Q�得到复杂设计根本就不可能是好的架构。时�ȝ��讎ͼ�架构是妥协啊...

最后，pair programming是simple design的实际检验！�Q�！因�ؓ即便是最复杂的设计，只要是你自己惛_��来的�Q�你都觉得它��单无比，里面充满了直白且显而易见的理由。可惜不�q�的是，我们要的��单，是对team里所有�h的简单。如果你的pair不能理解你的设计�Q�那么说明你的设计复杂了;如果你们两个人懂�Q�但是swith pair的时候，换过来的��Z��懂，说明你的设计复杂了。pair programming(以及他那�Ҏ��让�h忽略的子实践switching pair)��是��验simple design的过�E�。pair programing + refactor��是时刻保证simple design防止�q�渡设计反攻倒算的过�E�。pair programming + refactor + tdd��是团结在以Deming同学built quality in的质量大旗下�Q�坚定地与过渡设计做斗争的过�E�。据我观察，��x��有��用pair programming的团队中�Q�少一半simple design成了口号�Q�而这一半中�Q�至��又有一半最�l�放弃了xp攑ּ�了敏��P��Z��前带�q�的团队��有�q�样�?..默哀一下）。深�ȝ��教训啊，我们来高��g��下："pair programming是检验simple design的唯一标准�Q?�?br />
最后说一下pair programming�l�济学，�q�多的假设我��׃��讲了。单说一点，有哪一位上班的8��时从来不上msn/yahoo/qq�{�im?有哪一位上班从来不上论�?不回�?不发邮�g?以我pair的经验来看，pair programming的过�E�中�Q�两个�h几乎不会用im�Q�几乎不会逛论坛。你不好意思呀�Q�毕竟不是你一个�h的机器，毕竟是两个�h的时��_��毕竟你也不愿意给同事一�U�懒散的印象吧？收回的这么浪费的旉��Q�至��顶得过另外一个�h的工作时间了吧？

Raimundox 2007-03-27 14:52 发表评论

Agile Development �Q?a Quality Management Perspective

Raimundox — Mon, 26 Mar 2007 12:08:00 GMT

惌��理解敏捷软�g开发�ؓ什么好�Q�需要从软�g质量讲�v。那么��Y件的质量是什么？�q�个问题有很多中�{�案�Q�我们不妨想看看传统质量理论对于质量是如何理解的。教�U�书上说�Q�在20世纪质量��理的发展历�E�经历了质量��验、统计质量控制和全面质量��理三个阶段。其中，质量理念也在不断的演变。据说有�q�么几个阶段�Q?br />
�W�合性质�?br />20世纪40�q�代�Q�符合性质量概念以�W�合现行标准的程度作��量依据，“符合标准”就是合格的产品质量�Q�符合的�E�度反映了��品质量的水��^。比如说我做一个杯子，没什么特别的要求�Q�也不是我神�l�质的艺术作品，��是普普通通的一个杯子，那么需要高矮长短，大小胖瘦�Q�等�{�一�q�质量属性，我做好了可以拿着质量标准来对比，一眼就可以看出那里��Z��什么问题。通过是否�W�合�q�些标准判断产品��h��相应的质量�?br />那么软�g的质量理是不是符合性质量呢�Q�我个�h觉得不属于。虽然我们一样可以拿出各�U�各��L��标准�Q�比如故障率�Q�比如bug数等�{�。但是这些标注都满��不一定是好的软�g�Q�比如我写一个helloworld�Q�虽然他可以没有bug。但是却发挥不了��M��的作用。这��L��软�g��属于“高质量”的废品。正如�n辛梅评�h斚w�`渐，“你不讨厌，但是毫无用处。”，昄��毫无用处的��Y件不会是真正高质量的软�g�?br />
适用性质�?br />20世纪60�q�代�Q�适用性质量概念以适合��֮�需要的�E�度作�ؓ衡量的依据，从��用的角度定义产品质量�Q�认��量就是��品的“适用性”。是“��品在使用时能够成功满��用户需要的�E�度”。质量涉及设计开发、制造、销售、服务等�q�程�Q��Ş成了�q�义的质量概��c��适用性质量的例子也很多，比如我买了一件Givenchy西服�Q�我�q�真��C��一�Ӟ��Q�但是一时又没有特别正是的场合（目前�q�真没有什么正式的场合�Q�，于是我一天四��牛排（其实只有一��）�Q�于是就吃胖了，�q��g华丽的Givenchy��q��不上了。那么这件衣服从�W�合性质量来��_��是优质品�Q�但是从适用性质量来��_��却不是一个高质量的��品——因为我�I�不上。还有一句话�Q�叫甲之熊掌乙之砒霜。也是适用性质量的标准体现�?br />那么软�g的质量是不是适用性质量呢�Q�我个�h觉得�Q��Y件的质量臛_��是适用性质量。��Y�Ӟ��其是定制��Y�Ӟ��企业软�g�Q�就是量体裁衣。��Y件的基本质量��是要在用户使用的过�E�中发挥价��|��支撑客户的业务发展�?br />书上��_��从“符合性”到“适用性”，反映了�h们在对质量的认识�q�程中，已经开始把��֮�需求放在首要位�|�。但是它没说怎么才能做到把客户需求放到首要位�|�。我看光靠文档是堆不出来的，光考说说也是不行的。这个后面讲�Q�戴明同学比我讲得好�?br />
满意性质�?br />20世纪80�q�代�Q�质量管理进入到TQM阶段�Q�将质量定义为“一�l�固有特性满��求的�E�度”。它不仅包括�W�合标准的要求，而且以顾客及其他相关�Ҏ��意�ؓ衡量依据�Q�体现“以��֮�为关注焦点”的原则。这个的最典型的例子是麦当劻I��他所有的店铺从风格到食物都保持在同一水��^�Q��你无论在那里�Q�都可以得到一定的购物体验。也��构成了寚w��当劳的满意性质量的验证。这个��Y件上也是有例子的�Q�内举不必亲�Q�ThoughtWorks大多数项目都可以辑ֈ�“满意性质量”，呵呵谁让��Z��是consultant涅�?br />我隐�U�觉得满意性质量应该是一个过�E�的质量�Q�而不仅仅是��Y件的质量�Q�但是目前没有好的想法，暂且按下不表�?br />
卓越质量
......下略100字。个��得大多数软�g�q�没有达到适用性质量，大多是过�E�也都没有达到满意性质量，卓越质量��先不说了吧�?br />
��M��Q�我们大体的认�ؓ软�g质量主要是适用性质量�v码是不会错的。那么怎么才能辑ֈ��q�个质量标准涅？俺是做��Y件的�Q�质量管理还是看看Deming同学怎么说吧�Q�不�q�他老�h家的14�Ҏ��L��发生变化。我也只好断章取义，说说一个敏捷开发�h员眼中的14原则�Q?br />
1. 持之以恒地改�q��品和服务 Create constancy of purpose for improvement of product and service

�q�个很明昑֘��Q�small release�Q�快速发布，每次发布都是对��品的持箋改进�?br />
2.采用新的观念 Adopt the new philosophy

敏捷�?..

3.停止依靠大规模检查去获得质量 Cease dependence on mass inspection

�q�个�q�有另一个说法，build quality in。TDD�Q�QA/BA全程参与�Q�都是build quality in的好�Ҏ��?br />
4.�l�束只以��h��为基��的采购习�?End the practice of awarding business on the basis of price tag alone

�q�个...貌似是说请咨询吧...

5.持之以恒地改�q�生产和服务�pȝ�� Improve constantly and forever the system of production and service

�q�个是敏捯��E�的持箋改进�Q�对应的实践大家可能比较陌生——Restrospective!!!

6.实行岗位职能培训 Institute training on the job

Pair Programming�Q�Learning Lunch敏捷从来都不�~�Z��学习的机会，��q��你有没有学习的动力了�?br />
7. 建立领导力企业管�?Institute leadership

敏捷团队的终极目标，自组�l�团队，的管理是也�?br />
8. 排除恐惧 Drive out fear

XP�W�一原则�Q�勇气，不要恐惧�?br />
9. 打破部门之间的障��?Break down barriers between staff areas

只有开发团队的敏捷不是真正的敏��P��敏捷说到底，是将软�g的供求关�p�M��合约型�{为合作型�Q�本来就要是大破障碍。而且障碍不打��_��很隑ְ�敏捷实施到底。这也是很多同学��试敏捷��p�|的原因，仅仅以�ؓ敏捷是技术层面上的事情，其实不是。从�q�个角度来所�Q�敏��h��法的��是深刻而震撼心�늚�变革�Q�有些�h...�?..敏捷在十�?..

10. 取消对员工的标语训词和告�?Eliminate slogans, exhortations, and targets for the work force

恩，什么激�?00�?..��闭开�?..见鬼��d��...不过restrospective的结果是要写在白板上的，准备时刻改进。自我表扬和自我批评�Q�算不上训词吧�?br />
11.取消定额��理和目标管�?Eliminate numerical quotas for the work force. Eliminate management by objectives

很多人都问过我，pair programming了之后，技校怎么办？嘿嘿�Q�Deming同学已经说了�Q�这��L��考核不要也�Ş�?br />
12 消除打击员工工作情感的考评 Remove barriers that rob the hourly worker of his right to pride of workmanship. Remove barriers that rod people in management and in engineering of their right to pride of workmanship

敏捷团队的自我评价很��单，360度，�׃��你几乎跟所有�h都pair�q�，如果所有�h都不说你�?..�q�已�l�是rp问题了，��׃��是打击这么简单了...

13 鼓励学习和自我提高�?Encourage education and self-improvement for everyone

同前�Q�Pair Programming�Q�Learning Lunch敏捷从来都不�~�Z��学习的机会，��q��你有没有学习的动力了�?br />
14 采取行动实现转变 Take action to accomplish the transformation

每次restrospective之后必须定出�Ҏ��Q�以实践改进。而诸位如果想实施敏捷又觉得难于说服领带，不妨拿Deming同学说说事，�q�位大老的杀伤力�q�是曼大的，��其你老大是MBA的话

Raimundox 2007-03-26 20:08 发表评论

Why Rails so effective? Delphi Inside

Raimundox — Fri, 23 Mar 2007 04:10:00 GMT

很长旉��以来我对rails框架本��n没什么兴��，因�ؓ我从来都不是web fans�Q?5岁那�q�我打印了一本HTML Reference准备学习一下，感觉完全nonsense。很长一�D�|��_��大约�?�q�吧�Q�里基本上看到Markup Language我就会大脑短路。但是我对rails背后的东西很感兴��，是什么让rails如此有效率，一开始我以�ؓ是Ruby DSL�Q�但随着做的rails��目��来��多�Q�我发现rails的效率的�Ҏ��来自它对delphi的��承和发扬�?br />
1. data centric object model Active Record
delphi之所以成功，在于它看准了大部分商用��Y仉��是数据库核心的，�q��ؓ之设计一套相应的框架, delphi的核心就是围�l�数据库�q�行开�?李维同学的borland传奇里写道，当时之所以�v名字叫Delphi�Q�就是因��taking to Oracle)。而rails也很好的在新时代(Web时代)把握了相似的核心点——content是web的核心，以及数据库数据到content的映��是动态web的核心。因此它没有采用所谓的更加严肃的ORM技术。而是依然使用了delphi时代的active record�Q�但是进行了object��装�Q�。如下代码示范了ruby和delphi在active record实现上的�怼�

Ruby

class Person < ActiveRecord::Base
end

x8x = Person.new :name => 'x8x'
x8x.age = 15

Delphi

people : TADOTable;

begin
   people.Table = 'people';
   people.InsertRecord('x8x');

   people.First;
   people.FieldByName('age') := 15;
end

可以看出�Q�Delphi的数据库味道更浓一些，而ruby则更多��用了对象的视角（我记得在98�q�前后（我变成oo狂热分子之后�Q�，在写delphi的时候我基本上不会直接��用Table对象了，而是做一些简单的��装�Q�用business object代替直接的数据库对象。但是最后由于和delphi的ui�l��g�l�合的不好而放弃）。但是active record的pattern是一致的�?br />
2. DB(resource)-aware UI component —�?Action View

Delphi另一个�ؓ人称道的地方是DB�Q�Aware的UI�l��g�Q�像TDBLabel, TDBMemo�q�有至今仍位人称道的TDBGrid�Q�极大的��化了UI的开发。不�q�说到底�Q�仍然是Delphi数据库核心策略的延箋。同��P��rails的view helper也是db核心的。text_field之类的可以自动感知active record的内容和错误�?br />

<label>Name:label> <%= text_field 'person', 'name' %>

�?br />

nameLabel : TDBLabel;

nameLabel.DataSource = peopleTable;
nameLabel.Field = 'name';
nameLabel.Label = 'Name';

抛开Desktop和web的差异，也可以算是大致相当吧�?br />
3. Simple Component Model —�?Plan Object as Component

Delphi是基于组件开发，�q�且是非常成功的一个组件模型。基本上有经验的delphi�E�序员，都会在开发过�E�中抽象几个VCL component出来��化自��q��开发。一斚w��是DRY�_��Q�另一斚w��Delphi��单的�l��g模型使得�q�样做的代�h非常的小。Delphi的组件基本上��是一个对象，重构的过�E�中修修�Ҏ��成�l��g了。rails其实有类似的机制�Q�而且更简单直接，更符合web时代的胃口，一个对象外加一个helper��可以成��Z��个UI�l��g。与此同时rails�q�有另外一个天然的同盟——Ruby DSL。把以前Delphi需要用UI设计器的地方都用Ruby DSL代替了。这一�Ҏ��我最�q�在用rails做曹老师华丽的RedSaga的时候推行DSL geek��M��时发现的。比如现在我有这样一个tiny DSL用以定义portlet�Q?br />
in controller

@portlet = Portlet.new do
            name 'administration'
            title 'Administration'
            tabs do
                Projects :controller =>'projects', :action => 'list'
            end
        end

in view

<%= render_portlet @portlet %>

�q�种描述/configuration block风格的dsl与delphi�l��g的初始化非常�怼��Q�或者可以说�Q�只有语法上的差异而无思�\上的差异�Q�当然delphi可以借助IDE而不是语�a�来指定这些，但是�q�个做法是没有生产力的）�?br />

with Portlet do
   Label =
   Name = .
   Tabs[0].Controller =
   Tabs[1].Action =
end

rails和delphi�q�种轻量的组件模型，使得构徏�l��g�Q�复用组件��的代��h��。因此可以极大的提高开发效�?我至今仍记得�Q?1�q�前后接了一个Delphi�U�活�Q�客戯��求Office XP菜单风格�Q�我找了一个XPMenu的控�Ӟ��直接仍上去，自己的代码一行没改，菜单��Office XP�?..)�?br />
��M��Q�Delphi的效率要素Rails大部分都学走了，最后简单�ȝ��一下rails在delphi基础上的发扬�Q?br />
1. 用ruby而不是object pascal。语法上更灵�zȝ��?br />2. Object Model on top of ActiveRecord�Q�比起Delphi可以跟好的��用OO开发�?br />3. �l��g模型更简�?br />4. CoC�Q�这个就不说�?br />5. expressive Ruby DSL

最后最后，说一下Delphi for PHP�Q�做得很华丽。但是UI部分我不是很喜欢�?br />

Raimundox 2007-03-23 12:10 发表评论

The Starting Line of Enter...tainment Ruby

Raimundox — Thu, 25 Jan 2007 14:08:00 GMT

I got a Sony PSP recently. After playing with it for a while, I found out that, comparing to other handheld game console, PSP has a fairly open platform. Some great guys had already customized a gcc compiler for PSP, and also, a simple toolchain is provided by the active community to support porting/development/debuging/hacking. So I decided to port some of my favourite programming langauges to PSP. Of course, the first one on my list is Ruby.

Cross compiling, reading psp documents, reading ruby source code, hacking ruby source code, cross compiling... after 3 days hard working, finally, I managed to make the following ruby script(which is listed in the book ) running on my PSP:

def say_goodnight(name)
"Good night, #{name}"
end

puts say_goodnight("PSP")

Bingo~~~! Ruby goes entertainment!!!!

btw : my ruby-psp patch could be found here:
https://rubyforge.org/tracker/index.php?func=detail&aid=8134&group_id=426&atid=1700

make sure you have psp-gcc and toolchain installed on you PC, and 3.03-OE/1.5 fireware on your PSP.

Raimundox 2007-01-25 22:08 发表评论

An Issue of Chinese Characters Support in Ruby Watir

Raimundox — Thu, 12 Jan 2006 02:26:00 GMT

Watir doesn't work well with chinese characters. Try the following codes.

ie.text_field(:name, 'some text field).set('某某')

It will highlight the text field but put nothing in it. I read the Watir source codes, and found an interesting code segment:

1 for i in 0 .. value.length-1
2    sleep @ieController.typingspeed   # typing speed
3    c = value[i,1]
4    #@ieController.log  " adding c.chr " + c  #.chr.to_s
5    @o.value = @o.value.to_s + c   #c.chr
6    fire_key_events
7 end

The above codes show how Watir simulates typing.If it doesn't work well with chinese characters, There must be something wrong with Ruby string. The first order of business is to figure out how Ruby string works for Chinese string.

1 chineseString = '某某'
2 puts chineseString.length
3 for i in 0..chineseString.length-1
4 puts chineseString[i, 1]
5 end

result will be:

Does Ruby, which is now capturing all java programmers' love, use 8bit char instead of unicode? Holy fuck!

I made a simple patch for the issue after I woke up from a short coma.

1 require 'Watir'
2
3 module Watir
4   module Cn
5     class IE <Watir::IE
6       def text_field(how , what=nil)
7         return TextField.new(self, how, what)
8       end
9     end
10
11     class TextField < Watir::TextField
12       def doKeyPress( value )
13         begin
14           maxLength = @o.maxLength
15           if value.length > maxLength
16              value = suppliedValue[0 .. maxLength ]
17              @ieController.log " Supplied string is #{suppliedValue.length} chars, which exceeds the max length (#{maxLength}) of the field. Using value: #{value}"
18           end
19         rescue
20           # probably a text area - so it doesnt have a max Length
21           maxLength = -1
22         end
23
24         Cn.characters_in(value) {|c|
25            sleep @ieController.typingspeed
26            @o.value = @o.value.to_s + c
27            fire_key_events}
28        end
29      end
30
31      def Cn.characters_in(value)
32        index = 0
33        while index < value.length
34          len = value[index] > 128 ? 2 : 1
35          yield value[index, len]
36          index += len
37        end
38      end
39    end
40 end

I submitted this patch to Watir tracing systsem,and zipped codes could be found here:
http://rubyforge.org/tracker/index.php?func=detail&aid=3232&group_id=104&atid=489

Raimundox 2006-01-12 10:26 发表评论

A Pragmatic Way to Make "Squeak 3D Browser"

Raimundox — Tue, 27 Dec 2005 08:54:00 GMT

There is an article about how to make a "Squeak 3D Browser".And the nice guy who wrote the article also put a flash demo.It's an amazing demo to show how interesting programming in Squeak could be.But I don't like the too-many-GUI-way which the guy used. I thought there might be a more pragmatic way to do the same thing so I spent an hour on making a script, and finally I got it ;-)

Preferences enable: #systemWindowEmbedOK.

myBrowserWindow := Browser new openEditString:#Hello.
myBrowserWindow setLabel:'System Browser'; bounds: (Rectangle left:20 right:600 top:20 bottom:400).

my3DIDE := Wonderland new.
my3DIDE getDefaultCamera getMorph bounds: (Rectangle left:20 right:800 top: 20 bottom: 600).

my3DBrowser := my3DIDE makePlaneNamed: 'System Browser'.
my3DBrowser setY:50; turn:#right turns:0.38;
                setProperty: #adjustToTexture toValue: true;
                setTexturePointer: myBrowserWindow;
                setProperty: #activeTexture toValue: true.

Try it and have fun!

Raimundox 2005-12-27 16:54 发表评论

I'm a RSSer

Raimundox — Tue, 20 Dec 2005 13:48:00 GMT

RSS may be one of the most delusive terms, it could stand for 'RDF Site Summary', 'Rich Site Summary', 'Really Simple Syndication' or other things.Today I introduce a brand-new meaning of RSS: Ruby.Smalltalk.Scheme, which are my beloved top 3 programming languages in ascending order.The more I write in Ruby, the more I think in Smalltalk;And the more I think in Smalltalk, the more I love Scheme.Abstract concepts in Scheme, think objects in Smalltalk and write codes in Ruby, cool!

Raimundox 2005-12-20 21:48 发表评论

A Walk On JSR220 Persistent API...More Ugly More Cool

Raimundox — Tue, 13 Dec 2005 11:25:00 GMT

Frank and I collected some Hibernate tips, and we named them with some sexy names ;-) This afternoon I tried to replace hibernate by JSR220 persistent API in a typical web application, and I found some new tips in JSR220 Persisntent API (Frank, I'm here waiting your names).

btw: I'm a believer in Peter Coad's Color Modeling approach, all the following tips are modeled in the approach. I recommend you the greate book 'Java Modeling in Color with UML' if you'd no idea about the Color UML.

1. Annotating Description with @Embeddable, and the Thing it describe with @Entity

Take Product and ProductDescription for example.

1@Embeddable
2class ProductDescription {
3 private String name;
4 private String description;
5 . and getters and setters
6}
7
8@Entity(access = AccessType.FIELD)
9class Product {
10
11 private ProdcutDescription description;
12
13}
14

In hiberante, we could make the ProductDescription as an embedded persistent object of Product via the component tag.If the ProductDescription should be embedded in another object, we've to declare it once more.
Things become more convenient in JSR 220, because non-transite fields, whose class is annoated with @Embeddable, are treated as embedded persistent objects automatically, we'd have fine-grained persistent objects without long-winded config file.

2.Avoiding Database Field in Domain Model Using @AttributeOverride

It's claimed that Annotaton could simplify development, but considering the cost of hard-coding mapping information in source codes I prefer some other complicated ways.It's too ugly to write code like following.

1@Entity(access = AccessType.FIELD)
2@Table(name="TAB_PRODUCT")
3class Product {
4
5   @Basic
6   @Column(name="NAME", nullable=false, length=512)
7   private String name;
8}

It's sucks but could be avoided.

1@EmbeddableSuperclass
2class Product {
3
4 @Basic
5 private String name;
6}
7
8@Entity
9@AttributeOverride(name="name", column=@Column(name="Name"))
10@Table(name="TAB_PRODUCT")
11class PersistentProduct extends Product {
12}

We could separate the domain model and the persistent model by inheritance.Although we could do the same thing in hiberante too, we have to provide lots of configuration files.Once more we'd have hierachical persistent objects without long-winded config file.

3.Avoiding Database Primary Key in Domain Model

In most O/R mapping framework, we are always asked to give a primary key or identifier to our domain model, and we are suggested using meanless identifier instead of domain-specified identifer.It's kinda of Domain Pollution.Although we couldmake the domain model more clearer via inheritance, it's pointless for common usages.
Fortunately, we HAVE TO separate domain model and persistent model(as above mentioned), so that we can throw this bad habit away conviniently :D

1@EmbeddableSuperclass
2class Product {
3}
4
5@Entity
6class PersistentProduct extends Product{
7
8 @Id private long primaryKey;
9}

Conclusion

After two hours walking around JSR220 persistent API, I figured out that JSR220 mixed ugly into convenience... and it's quite easy to write ugly codes in jsr220...so that we've to insist on using OO and the convenience jsr220 provided to make our domain model as clear as possible.
Although JSR220 is more ugly than hibernate, we could get clearer domain model in jsr220 rather than hibernate, because we could not stand the unly in jsr220...weird way to make us keeping more OO...cool isn't it...

Raimundox 2005-12-13 19:25 发表评论

Why Inconsistent Concepts Considered Harmful

Raimundox — Sat, 10 Dec 2005 17:59:00 GMT

Tao Wen , a friend of mine and a new ThoughtWorker, put a comment on my last article.

so, you think the consistent thing means a lot? But how do you think the gracious or elegant feeling mean to the real expressiveness of business requirements? We can see lisp is very successful in researching area because of the simplicity nature inside which is also true to Smalltalk. But why they aren't successful in biz world? I think that is the problem you should further study, "how can the consistent feeling mean something to our everyday programming life?".

First of all, I should admit that I'd never thought about this question before, becasuse I think hankering after consistent concepts is some nature of us. The question enlightens me to thinking deep. Here are my points.

1.Complexity

Inconsistent concepts bring complexity.I'll give two examples.

First one is something in Lisp. Lisp has a very simple computing model called λ Calculation. There are three elements in this computing model: Function, λ Operator and · Operator. λ Operator picks up free variable from the function, and · Operator applies the variable with a concrete value. The whole evaluation-application thing is what we called symbolic algebra in math.For example, if we've a function whose expression is x + y.

((λx (λy . x + y)·3)·4)
=((λx. x+3)·4)
=4 + 3
=7

Since Lisp is kinda implementation of λ Calculation in computer, we could do the same thing in Lisp (and its dialects).

(define f (lambda x (lambda y (+ x y))))
(apply (apply f 3) 4)

or we could use some syntax sugar

(define (f x y) (+ x y))
((f 3) 4)

Most of things in Lisp are focus on evaluation, and the evaluation should be done in a simple consistent way: evaluating, applying value and then returning the value without any change to enviroment. It is the very same way that we do something in math.
But variable assignment was introduced to Lisp, so some functions which change enviroment instead of simple evaluating came to Lisp.For example:

(define (bad-f x y)
  (begin
     (set! z 5)
     (+ x y)))

That bad function changes value of symbol 'z' while evaluating x + y. It is the variable assignment which breaks the consistent concepts. The consistent concepts suggests that function should do and only do evaluation. We must find a more complicated computing model to replace the simple elegant mathematical one.Here inconsistent brings complexities in computing model.

The other example comes from Java. Java is considered to be an object-oriented programming language with single root type system. Conceptually speaking, everything should be an object.But for some perfermance reason, Java has some primitive types (such as int, double, float etc.) too.Those primitive types introduced a algebraic world which paralleled to the object world, and broke the consistent concepts.Althought Java has some wrapper classes for those primtive types, they are not enough for filling the gulf between object and algebra.
We could use new Integer(3) to represent 3 in object world, but we could not simply translate

3 + 4 * 5

new Integer(3) + new Integer(4) * new Integer(5)

Algebraic calculation and object message sending are totally different. Although we could do that in Java 5, it also has lots of differences.Auto-boxing treats object as primitive instead of operator overloading in C++ which treats operator as object message sending.So in my opinion, auto-boxing in java5 is awful. Assginments and storage of primitive type and object have lots inconsistent semantics too. This inconsistent would bring complexity when we use Collection API(Remember Primitive Collection in Commons Collection Project? )

2. Side-Effect

The mainly cause of side-effect is putting some inconsistent concepts together. I'll also give two examples.

First example is the well-known side-effect in functional programming, which is caused by mixing Von-Nouma-style-things into λ Calculation. There are lots of discussion about this topic in functional programming community.It's meanless to repeat that again.

Second example comes from half-blooded object-oriented languages, for we'll find both object-oriented things and procedure-oriented things in these languages, and it'll be much more easier to write code in procedural way instead of object-oriented way.For example, we'd write code like this:

1if (order.getState() == Order.CANCEL)
2   do something for cancel;
3else if(order.getState() == Order.PAID)
4   do something for paid;
5else if(order.getState() == Order.DELIVERY)
6   do something for delivery

instead of :

1public abstract OrderState {
2
3   protected Order _order;
4
5   protected OrderState(Order order){
6      _order = order;
7   }
8
9   public abstract void handler();
10}
11
12class CancelState extends OrderState {
13
14   public void handler() {
15      do something for cancel;
16   }
17}
18
19order.getState().handle();

For the keywords, it's convenient to write procedural codes as first segment, but for easy maintenance, it's better to write object-oriented codes as the second one.There are two inconsistent way to write code, and the side-effect is depend on how object-oriented the language is. It's more easy to write code like first one in C++ , and more easy to write code like second one in Ruby and Smalltalk. Actually, it's very hard for me to write code like first one in Smalltalk.

3. Constructing Software in a Recursive Way

There is a more large topic, maybe I'd better talk about this latter.

4. Elegance

Some aesthetic feelings comes from consistent concepts.I'll have the feeling of elegance if I could understand some complicated things via some consistent concepts.Take Newtonian System and Maxwell formula for example, they both are the elegant way to resolve problem via few consistent concepts.

Raimundox 2005-12-11 01:59 发表评论

Say sorry to Object-Oriented Methodology

Raimundox — Thu, 08 Dec 2005 12:39:00 GMT

Recently I came to know and started to learn Smalltalk, an age-old pure Object-Oriented programming language. I fell in love with it quickly. Smalltalk is a very small language with some consistent concepts and abundant class libraries. I was puzzled at the very begining, as Smalltalk has very few keywords(maybe 5 I think), and those keywords don't include any control structure(a.k.a if, while, for), how could we write programs? Althougth I know we could implement iterative sturucture via recursion, how about conditional execution? Finally I figured out that Smalltalk provides control strucutre in its class library only using some basic OO concepts. Followings are the codes from Smalltalk class library.

1Boolean>>ifTrue: alternativeBlock
2  self subclassResponsibility
3
4Boolean>>ifFalse: alternativeBlock
5  self subclassResponsibility
6
7"and True and False are subclasses of Boolean."
8
9True>>ifTrue: alternativeBlock
10  ^alternativeBlock value
11
12True>>ifFalse: alternativeBlock
13  ^nil
14
15False>>ifTrue: alternativeBlock
16  ^nil
17
18False>>ifFalse: alternativeBlock
19  ^alternativeBlock value

and then in some codes, we could do the conditional execution as follows

14 > 3 ifTrue: [Transcript show: 'Hello']

In Smalltalk, everything is Object, so that the code above means sending a message named '>' to an Integer object, whose value is 4, with an Integer object parameter. And '>' would return a Boolean object, and then we sent a message named 'ifTrue' to it. This is a typical usage of State Pattern. Here are the equivalent Java codes.

1public class abstract Boolean {
2   public static final TRUE = new True();
3   public static final FALSE = new False();
4
5   public abstract Object ifTrue(Block aBlock);
6   public abstract Object ifFalse(Block aBlock);
7}
8
9class True extends Boolean {
10
11   public Object ifTrue(Block aBlock) {
12       return aBlock.execute();
13   }
14
15   public Object ifFalse(Block aBlock) {
16       return null;
17   }
18}
19
20class False extends Boolean {
21
22   public Object ifTrue(Block aBlock) {
23       return null;
24   }
25
26   public Object ifFalse(Block aBlock) {
27       return aBlock.execute();
28   }
29}
30
31public class Integer{
32
33   public Boolean greaterThan(Integer anInteger) {
34
35   }
36}
37

So that we could get the following code

14 �?/SPAN>3 ifTrue: [Transcript show: 'Hello']

which could be translated in Java like this:

new Integer(4).isGreaterThan(new Integer(3)).ifTrue(new BlockClosure() {

   public Object value() {
      System.out.println("Hello");
      return null;
   }

});

That's quite simple(some dynamic languages on JVM ,e.g. Groovy, do the same thing), but it indeed brings some profound changes to my thought.

First, considering that 'if'�Q?/SPAN>'for' and 'while' are no longer pre-defined keywords, we could define our own control structures. For example, we could define Order has its own way to do something.

1anOrder ifExpired: [ do reactive order]
2 ifCanceled: [do something else]

Taking no account of performance and semantic speaking, there is no difference between the code above and undermentioned:

1 4 >3 ifTrue: [do something]
2 ifFalse: [do somthing]

More fancy, we could define a new test structure like this:

1anOrderTest should: [some assert] when: [do some initalize].

So we could have programmable control structure in Smalltalk ( something like we do in Lisp via continuation:) ), and define our own DSL easily.That's the amazing lightweight syntax feature in Smalltalk!

Second, we could get full capability of Von Nouma Style Programming Language via pure OO concepts.We could construct software in consistent OO concepts.

I began my adventure in Object technology by using C++ in 1995, and then I chose Java as my main working language. All my experiences about OO come from half-blooded OO language.So that for a long time, I thought Object-Oriented Programming is a big patch to imperative languages. The imperative languages are desgined to record the sequence of instruments which are used to manipulate the computer, so they are lack in semantic, and poor in abstraction. Though the Object technology introduces a successful type system and provides some abstraction mechanism, I still feel sucks to program in inconsistent concepts, because I should be careful about keeping programming more in OO-style rather than in procedural-style(something like Domina Model or not, sucks!).

Once I accused Object-Oriented Methodology of all the fault, I blamed imperfection on Object-Oriented Methodology.But now, I found out it's only because that I have little talent and learning in OO, it turned out to be my fault, I should say sorry to Object-Oriented Methodology.

Raimundox 2005-12-08 20:39 发表评论