博客园_QA MichaelPeng

用马尔科夫模型做拼写检查

2011-05-13T09:12:00Z

原理和原文见 Peter Norvig的这篇文章

原文是基于词频，在文后提到可以通过上下文来提高准确率

下面这段代码只考虑了待纠正词在序列末尾的情况，应当还要考虑其在序列中和序列首的情况

import re, collections, sys, random

def words(text): return re.findall('[a-z]+', text.lower())


def defaultdict_factoryn(n, default):
    if n == 1: return lambda: default
    return lambda: collections.defaultdict(defaultdict_factoryn(n-1, default))

def multidict_set(d, l, v):
    curd = d;
    i = 0
    for ele in l:
        i += 1
        if i == len(l):
            curd[ele] = v
        else:
            curd = curd[ele]

def multidict_add(d, l, v):
    curd = d;
    i = 0
    for ele in l:
        i += 1
        if i == len(l):
            curd[ele] += v
        else:
            curd = curd[ele]

def multidict_get(d, l):
    curd = d;
    i = 0
    for ele in l:
        curd = curd[ele]
    return curd

def train(features, n):
    model = collections.defaultdict(defaultdict_factoryn(n, 1))
    prevlen = n
    prev = collections.deque()
    for f in features:
        if (len(prev) < prevlen):
            prev.append(f)
            continue
        multidict_add(model, prev, 1)
        prev.popleft()
        prev.append(f)
    return model

def most_likely(prev):
    l = multidict_get(Model, prev)
    if not l:
        return ""
    l = l.items()
    if len(l) == 0:
        return ""
    l = sorted(l, cmp=lambda x, y:y[1] - x[1])
    count = min(len(l) - 1, 10)
    return l[random.randint(0, count)][0]

stage = 1
Model = train(words(file('big.txt').read()), stage + 1)

def train_1(features):
    model = collections.defaultdict(lambda: 1)
    for f in features:
        model[f] += 1
    return model

NWORDS = train_1(words(file('big.txt').read()))

alphabet = 'abcdefghijklmnopqrstuvwxyz'

def edits1(word):
   splits     = [(word[:i], word[i:]) for i in range(len(word) + 1)]
   deletes    = [a + b[1:] for a, b in splits if b]
   transposes = [a + b[1] + b[0] + b[2:] for a, b in splits if len(b)>1]
   replaces   = [a + c + b[1:] for a, b in splits for c in alphabet if b]
   inserts    = [a + c + b     for a, b in splits for c in alphabet]
   return set(deletes + transposes + replaces + inserts)

def known_edits2(word):
    return set(e2 for e1 in edits1(word) for e2 in edits1(e1) if e2 in NWORDS)

def known(words): return set(w for w in words if w in NWORDS)

def correct(prev, word):
    # print [(c, NWORDS.get(c)) for c in candidates]
    if len(prev) < stage:
        candidates = known([word]) or known(edits1(word)) or known_edits2(word) or set([word])
        return max(candidates, key=NWORDS.get)
    else:
        candidates = known([word]) | known(edits1(word)) | known_edits2(word) | set([word])
        return max(candidates, key=lambda x:multidict_get(Model, prev + [x]))

print correct(["i"], "ove")
print correct([], "ove")

本文链接

商业软件编程很无聊(转载)

2011-04-29T03:07:00Z

原文是ThoughtWorks一哥们在06年写的But Martin, Enterprise Software IS Boring，中文世界里Google前几页主要都是g9的那篇商业软件编程很无聊，没找到原文译本

因原文在墙外，就拷贝到墙内一份

But Martin, Enterprise Software IS Boring
Martin Fowler writes about Customer Affinity, a factor he believes distinguishes a good enterprise developer from a bad one. So far,so good.
He says "I've often heard it said that enterprise software is boring, just shuffling data around, that people of talent will do "real" software that requires fancy algorithms, hardware hacks, or plenty of math."
This is almost exactly what I say.(Just remove the quotes around "real" ;-) ).
Martin goes on to disagree with this idea (which is fine) but then he says "I feel that this usually happens due to a lack of customer affinity." And this is where I disagree.
People who work on things like compilers and hardware hacks and "tough" algorithmic problems can have customers, just as the enterprise folks do. I know I have. The compiler I am writing now has a customer. The massively parallel neural network classifier framework I wrote a couple of years ago had a customer. The telecom fraud detection classifier cluster I worked on last year (along with some other talented programmers) is being used by a company which is very business (and customer) oriented. So the idea that a "customer" (and thus customer affinity) is restricted only to those folks who write database backed web apps is simply not true.
Math/algorithms/hardware hacks and the presence or absence of a "customer" (and thus, customer affinity) are orthogonal (you know, two axes at 90 degrees to each other) issues.
With the customer issue out of the way, let us examine the core issue - the notion that talented developers would preferto do stuff like compilers and algorithms instead of a business app (by which I mean something like automating the loan disbursal processes of a bank).
The best way to get a sense of the truth is to examine the (desired) flow of people in both directions. I know dozens of people who are very very good at writing business software who yearn wistfully for a job doing "plumbing" like compilers and tcp/ip stacks, but I've never yet seen someone who is very very good at writing a compiler or operating system (and can make money doing so) desperately trying to get back to the world of banking software. A programmer might code enterprise apps for money, but at night, at home, he'll still hack on a compiler.
It's kind of a "Berlin Wall" effect. In the days of the cold war, to cut through the propoganda of whether Communism was better than Capitalism , all you had to do was to observe in which direction people were trying to breach the Berlin Wall. Hundreds of people risked their lives to cross from the East to the West but practically no one went the other way. Of course this could just mean that the folks didn't appreciate the virtues of people's power and the harangues of the comissars but I somehow doubt it.
To see whether living in India is better than living In Bangladesh (or whether living in the United States is better than living in India) look at who is trying to cross the barriers and in which direction.
Economic Theory suggests another way of finding an answer. Suppose you were offered say 10,000$ a month for say 2 years, to develop the best business app you can imagine and say, 8000 $ a month, for the same two years to work on the best systems/research project you can imagine. Which one would you choose? Now invert the payment for each type of work. Change the amounts till you can't decide one way or another and your preference for either job is equal. Finding this point of indifference (actually it is an "indifference curve") will teach you about your preference for "enterprise over systems". I believe that while individuals will choose many possible points as their "points of indifference" on that curve, a majority of the most talented debvelopers would prefer a lower pay for a good systems/research project in preference to an enterprise project, no matter how interesting. And to most developers, an enterprise project becomes interesting to the degree it needs "tough programming" skills (massively scalable databases say.. there is a good reason Amazon and Google emphasize algorithms , maths and other "plumbing" skills in their interviews and an equally good reason why a Wipro or a TCS doesn't bother testing for these skills).
The widespread (though not universal) preference of the very best software developers for "plumbing" over "enterprise" holds even inside Thoughtworks (where Martin works and where I once worked). I know dozens of Thoughtworkers who'd prefer to work in "core tech". While I was working for TW, the CEO,Roy Singham, periodically raised the idea of venturing into embedded and other non enterprise software and a large majority of developers (which invariably included most of the best devs) wanted this to happen. Sadly, this never actually came to pass.
A good number of thoughtworkers do business software to put bread on the table, or while working towards being good enough to write "plumbing", but in their heart, they yearn to hack a kernel or program a robot. (Another group of people dream about starting their own web appp companies). For most of these folks tomorrow never quite arrives, but some of the most "businessy" developers in Thoughtworks dream of writing game engines one day or learning deep math vodoo or earning an MS or PhD. And good people have left TW for all these reasons. And if this is the situation at arguably the best enterprise app development company (at least in the "consultants" subspace) one can imagine the situation in "lesser" companies.
The programmer who has the ability to develop business software and "plumbing" software and chooses to do business app development is so rare as to be almost non existent. Of course, most business app dev types are in no condition to even contemplate writing "hard stuff" but that is a topic for another day.
Paul Graham (admittedly a biased source) says (emphasis mine),
"It's pretty easy to say what kinds of problems are not interesting: those where instead of solving a few big, clear, problems, you have to solve a lot of nasty little ones....Another is when you have to customize something for an individual client's complex and ill-defined needs. To hackers these kinds of projects are the death of a thousand cuts.
The distinguishing feature of nasty little problems is that you don't learn anything from them. Writing a compiler is interesting because it teaches you what a compiler is. But writing an interface to a buggy piece of software doesn't teach you anything, because the bugs are random. [3] So it's not just fastidiousness that makes good hackers avoid nasty little problems. It's more a question of self-preservation. Working on nasty little problems makes you stupid. Good hackers avoid it for the same reason models avoid cheeseburgers."
Strangely enough, I heard Martin talk about the same concept (from a more positive view point, of course) when he last spoke in Bangalore. He explained how much of the complexity of business software is essentially arbitrary - how an arcane union regulation about paying overtime for one man going bear hunting on Thanksgiving can wreck the beauty of a software architecture. Martin said that this is what is fascinating about business software. But he and Paul essentially agree about business software being about arbitrariness. It is a strange sense of aesthetics that finds beauty in arbitrariness, but who am I to say it isn't valid?
Modulo these ideas, I agree with a lot of what Martin says in his blog post. The most significant sentence is
"The real intellectual challenge of business software is figuring out where what the real contribution of software can be to a business. You need both good technical and business knowledge to find that."
This is so true it needs repeating. And I have said this before.To write good banking sofwtare, for e.g. you need a deep knowledge of banking AND (say) the j2ee stack. Unfortunately the "projects and consultants" part of business software development doesn't quite work this way. I will go out on a limb here and say that software consulting companies in general (with the rare honorable exception blah blah ) have "business analysts" who are not quite good enough to be managers in the enterprises they consult for and "developers" who are not quite good enough to be "hackers" (in the Paul Graham sense).
Of course factoring in "outsourcing" makes the picture worse. By the time a typical business app project comes to India, most, if not all of the vital decisions have been made and the project moves offshore only to take advantage of low cost programmers, no matter what the company propoganda says about "worldwide talent", so at least in India this kind of "figuring out" is almost non existent and is replaced by an endless grind churning out jsp pages or database tables or whatever. It is hard to figure out the contribution of your software to people and businesses located half a world away, no matter how many "distributed agilists" or "offshore business analysts" you throw into the equation.
This is true for non businessy software also,though to a much lesser degree. The kind of work outsourced to India is still the non essential "grind" type (though often way less boring than their "enterprise" equivalents). The core of Oracle's database software for .e.g. is not designed or implemented in India. Neither is the core of Yahoo's multiple software offerings - the maintenance is, development is not. And contary to what many Indians say, this is NOT about the "greedy white man's" exploiting the cheap brown skins. You need to do hard things and prove yourself before you are taken seriously. Otherwise people WILL see you as cheap drone workers. That's just the way of the world).
And I say this as someone who is deeply interested in business. T'is not that I loved business less but I loved programming more :-).I'd rather read code than abusiness magazine but I prefer a business magazine to say, fashion news. I actually LIKE reading about new business models. I read every issue of The Harvard Business Review (thanks Mack) and have dozens of businessy books on my book shelf along with all the technical books. (I gave away all (300 + books) of my J2EE/dotNet/agile/enterpise dev type book collection , but that is a different story). I am working through books on finance and investing and logistics. I have friends who did their MBA in Corporate Strategy from Dartmouth or are studying in Harvard (or plan to do so). I have friends who work for McKinsey, and Bain and Co, and Booz and Allen, and Lehman Brothers. If I were 10 years younger (and thus had a few extra years to live), I'd probably do an MBA myself. And of course I have spent 10 years (too long, oh, too long) doing "enterprise" software. In my experience (which could turn out to be atypical),the "plumbing" software is way tougher and waaaaay more intellectually meaningful than enterprise software, even of the hardest kind. I might enjoy an MBA, but I will NEVER work in the outsourced business app development industry again even if I have to starve on the streets of Bangalore. I'll kill myself first. So, yeah I am prejudiced. :-). Take everything I say with appropriate dosages of salt.
And just so I am clear, I do NOT think Martin is deliberately obfuscating issues. I think Martin is the rare individual whoactually chooses enterprise software over systems software and is lucky enough to consistently find himself working with the best minds and in a position to figure out the business impact of the code he writes. This is very different from the position of the average "coding body", especially when he is selected more for being cheap than because he knows anything useful ("worldwide talent", remember :-) ).
Btw, Martin's use of the word "plumbing" is not used in a derogatory sense (though I've seen some pseudo "hackers" take it that way, especially since the word makes a not-so-occasional appearnce in many of his speeches) but more in the sense of "infrastructure". If you are such a "hacker" offended by the use of the term, substitute "infrastructure" for "plumbing" in his article. That takes the blue collar imagery and sting out of that particular word, fwiw.
I think Martin has very many valuable things to say. I just think he is slightly off base in this blog post and so I respectfully disagree with some of his conclusions.
But then again, it could all be me being crazy. Maybe enterprise software is really as fascinating as systems software, and writing a banking or leasing or insurance app really as interesting as writing a compiler or operating system.(and Unicorns exist , and pigs can fly).
Hmmmm. Maybe. Meanwhile I'm halfway under the wall and have to come up on the other side before dawn. Back to digging.

本文链接

VS2010 Debugger bug

2011-03-16T07:03:00Z

版本：vs2010，vs2010 sp1

现象: debugger不能正确处理局部变量的作用域

示例代码:

int _tmain(int argc, _TCHAR* argv[])
{
    int i = 5;
    int sum = 0;
    for (int i = 0; i < 10; ++i)
    {
        sum += i;
    }
    printf("%d\n", i);
    return 0;
}

在return语句处设置断点，可以看到printf输入为5,而watch中i值为10,10为循环语句中i的值，此处的i应为main函数中的i，值为5

本文链接

编程之初

2011-03-10T04:00:00Z

大一才摸计算机。计算机概论由谢柏青老师主讲。当时很多理科院系的计算机概论课讲了计算机组成和二进制后就讲fortran,谢老师则不然，讲完基本的计算机原理，先给我们讲了office应用，复制、粘贴、格式刷、excel图表和函数，这些现在司空见惯的东西当时让我们大开眼界，原来计算机还可以这么玩，在宿舍里就成了高手了，学习兴趣大增。此外谢老师没有习惯性的讲fortran,而是由学生自己选学fortran还是c,我们虽然什么都不懂，只是觉得c比fortran时髦一些，就学了c.从以后的经验来看，培养学生的兴趣和尊重学生的选择，谢老师的这两点就直接影响了偶这个码农的命运。

大一下上裘宗燕老师的算法和数据结构课，把所有编程题都做了一遍，大作业拿TruboC写了一个dos下的编辑器，为写作业还熬过通宵，但学到的东西得到了应用，收获很大。指针不再是C语言课上枯燥的东西，而是直接构建程序功能的利器。链接和数组也不仅仅是课本上的ADT,而会直接影响程序各种操作的性能。

除了上课，实践是很重要的一点，编程不是苦差事，而是件好玩的事，写程序可以不带任何功利色彩，只为好玩，能给人带来一种简单而纯粹的快乐。回想上大学时干过的事，用TurboC绘制分形，看见一个美丽的图案一点点在你眼前展开，这种震撼是其它快乐无法替代的。写过游戏修改工具，在游戏通关的同时顺便熟悉了windows编程。通过动态跟踪和分析汇编代码，找到注册码的那一刻，除了破坏的快感，对汇编和程序执行的运行时也有了深入了解。想玩象棋，解出《桔中秘》时同时知道了位运算的技巧、alpha-beta剪枝和hash表。

编程之初，不外乎一个玩字，好玩而已，其它都是副产品。

本文链接

编程之美 1.4买书问题常数时间空间解法

2011-02-05T09:22:00Z

题目:

在节假日的时候，书店一般都会做促销活动。由于《哈利波特》系列相当畅销，店长决定通过促销活动来回馈读者。在销售的《哈利波特》平装本系列中，一共有五卷，用编号0, 1, 2, 3, 4来表示。假设每一卷单独销售均需要8欧元。如果读者一次购买不同的两卷，就可以扣除5%的费用，三卷则更多。假设具体折扣的情况如下：

本数折扣

2 5%

3 10%

4 20%

5 25%

在一份订单中，根据购买的卷数以及本书，就会出现可以应用不同折扣规则的情况。但是，一本书只会应用一个折扣规则。比如，读者一共买了两本卷一，一本卷二。那么，可以享受到5%的折扣。另外一本卷一则不能享受折扣。如果有多种折扣，希望能够计算出的总额尽可能的低。

要求根据这样的需求，设计出算法，能够计算出读者所购买一批书的最低价格。

分析:

首先假设五册书分别为A,B,C,D,E,不失一般性可以假设Na>=Nb>=Nc>=Nd>=Ne

设所有书可以划分为k组,每组中书不重复,

则在最优解中有如下性质:

1 所有只包含一本书的组均只包含同一本书

若有两组包含一本书的组包含的书不同,则这两组合并,能得到更优解,与最优解矛盾.

2包含一本书的组只包含A

若包含书为A',若Na'==Na,则A,A'对调即可

若Na'<Na,则必存在某组包含A不包含A',则将只包含A'的组并入该组能得到更优解

3所有只包含两本书的组均包含相同两本书

组(A', B'), (A',C')折扣0.2重组为(A',B',C')与(A)折扣0.3

4包含两本书的组必包含A

若存在包含一本A的组,而两本书的组不包含A,则合并能得更优解

若不存在包含一本A的组,而两本书组包含为A',A'',则包含三本书,四本组必含A而缺A'者

(A', A''), (AXY), 折扣0.4不如(A''),(AXYA')0.8

(A',A''),(AXYZ)折扣0.9不如(A''),(AXYZA')1.25

5 包含两本书的组必包含B

同上证

6所有只包含三本书的组均包含相同三本书

(A,B,C),(A,B,D)折扣0.6,(A,B),(A,B,C,D)折扣0.9

7所有包含三本书的组均包含A

若存在只包含A的组,合并得更优

若存在只包含A, B的组(A,B)(XYZ)折扣0.4,不如(B)(AXYZ)折扣0.8

若不存在一,二本组,假设三本书组为(X,Y,Z),则必有包含A的四本组缺X,(X,Y,Z)(A,A',A'',A''')折扣1.1,不如

(Y,Z),(A,A',A'',A''',X)折扣1.35

8所有包含三本的组均包含B,C

同上可证

9所有包含四本书的组均包含A,B,C

设XYZW为

(ABC)(BCDE)折扣1.1,不如(B,C),(A,B,C,D,E)折扣1.35

其它情况同理可证

10包含五本书与包含三本书情况不会同时出现

(A,B,C),(A,B,C,D,E)折扣1.55,不如(A,B,C,D),(A,B,C,E)折扣1.6

由以上证明可得如下结论

每组均包含A,所有组数与A相同
所有包含两本及以上的组均包含B,组数与B同
所有包含三本及以上的组均包含C,组数与C同
三,五不并存

由此可得解法如下:

const double BuyBook::UNIT_PRICE = 8;
const double BuyBook::DISCOUNTS[5] = {1, 0.95, 0.9, 0.8, 0.75};
static const int BOOK_KINDS = 5;
double BuyBook::SearchFast(int* books)
{
    Sort(books);
    int g[5];
    g[0] = books[0] - books[1];
    g[1] = books[1] - books[2];
    g[2] = books[2] - books[3];
    g[3] = books[3] - books[4];
    g[4] = books[4];
    int t = min(g[2], g[4]);
    if (t > 0)
    {
        g[2] -= t;
        g[4] -= t;
        g[3] += 2 * t;
    }
    double sum = 0;
    for (int i = 0; i < BOOK_KINDS; ++i)
    {
        sum += g[i] * (i+1) * UNIT_PRICE * DISCOUNTS[i];
    }
    return sum;
}

本文链接

vc2010 std::tr1 bind库捉虫记

2010-12-27T14:54:00Z

前两天发现了VC2010 tr1库中bind实现的一个bug,当时只是作了记录,没有详细分析.但作为一个QA,不找出问题所在实在不算称职,于是就有了这篇捉虫记.

闲言少叙,书归正传,tr1库就不多作介绍了,有兴趣的同学可以去 wikipedia上看.bind,顾名思义,就是把参数与函数绑定,以利于我们进行函数式编程,是从boost的bind库引入的,对bind不是很了解的可以看陈硕同学的这篇

以boost::function和boost:bind取代虚函数

假定笔者是 vc2010的QA,在做bind的功能测试,开始用gtest写test case, (笔者一般用gtest作为C++测试框架,就写到文章中了,但ms肯定不会用啦.笔者不在ms,请勿对号入座)

先写几个简单的函数供测试之用.

int Add(int left, int right)
{
return left + right;
}
int Sub(int left, int right)
{
return left - right;
}
int Mul(int left, int right)
{
return left * right;
}

再写测试用例.先是几个简单的

1 把值绑定到函数指针

TEST(Bind, FundPtr_Values)
{
auto f0 = std::tr1::bind(Sub, 5, 3);
ASSERT_EQ(2, f0());
}

2 把值绑定到仿函数

TEST(Bind, Functor_Values)
{
auto f0 = std::tr1::bind(std::minus<int>(), 6, 4);
ASSERT_EQ(2, f0());
}

3 把占位符绑定到函数指针

TEST(Bind, FuncPtr_Placeholder)
{
auto f0 = std::tr1::bind(Sub, std::tr1::placeholders::_1, 8);
ASSERT_EQ(12, f0(20));
}

4 将占位符绑定到仿函数

TEST(Bind, Functor_Placeholder)
{
auto f0 = std::tr1::bind(std::minus<int>(), std::tr1::placeholders::_2, std::placeholders::_1);
ASSERT_EQ(12, f0(8, 20));
}

运行测试

testing::InitGoogleTest(&argc, argv);
int ret = RUN_ALL_TESTS();

一切OK.

来个复杂的,将bind返回结果再bind到函数,用于进行高阶函数演算.

TEST(Bind, SquareDiff_FuncPtr)
{
auto f0 = std::tr1::bind(Mul,
std::tr1::bind(Add, std::tr1::placeholders::_1, std::tr1::placeholders::_2),
std::tr1::bind(Sub, std::tr1::placeholders::_1, std::tr1::placeholders::_2));
ASSERT_EQ(16, f0(5, 3));
}

运行,一切OK,

再来一个仿函数版本

TEST(Bind, Squarediff_Functorptr)
{
auto f0 = std::tr1::bind(std::multiplies<int>(),
std::tr1::bind(std::plus<int>(), std::tr1::placeholders::_1, std::tr1::placeholders::_2),
std::tr1::bind(std::minus<int>(), std::tr1::placeholders::_1, std::tr1::placeholders::_2));
ASSERT_EQ(16, f0(5, 3));
}

编译 , wow,这是啥啊

Error 1 error C2664: 'int std::multiplies<_Ty>::operator ()(const _Ty &,const _Ty &) const' : cannot convert parameter 1 from 'std::tr1::_Bind_fty<_Fty,_Ret,_BindN>' to 'const int &' c:\program files\microsoft visual studio 10.0\vc\include\xxcallobj 13 1 boostDemo

发现问题了, 偶两眼开始放光.

现在就开bug么,不,太早了,总得指明问题在哪儿吧.是编译器还是tr1库实现的问题?怎么办?拿另一个库boost试试,正常

通过就是tr1的问题了

TEST(Bind, SquareDiff_BoostFunctor)
{
auto f0 = boost::bind(std::multiplies<int>(),
boost::bind(std::plus<int>(), _1, _2),
boost::bind(std::minus<int>(),_1, _2));
ASSERT_EQ(16, f0(5, 3));
}

编译运行,一切正常.

现在可以肯定是tr1库的问题么?还不能.也许对仿函数绑定是boost的扩展而tr1准标准并不支持呢?

打开标准,看bind参数的说明

template<class F, class T1, class T2, ...., class TN>

unspecified bind(F f, T1 t1, T2 t2, ..., TN tN);

1 Requires: F and Ti shall be CopyConstructible. INVOKE (f, w1, w2, ..., wN) ([3.3]) shall be a valid expression

for some values w1, w2, ..., wN.

2 Returns: A forwarding call wrapper g with a weak result type ([3.3]). The effect of g(u1, u2, ..., uM) shall

be INVOKE (f, v1, v2, ..., vN, result_of<F cv (V1, V2, ..., VN)>::type), where cv represents

the cv-qualifiers of g and the values and types of the bound arguments v1, v2, ..., vN are determined as

specified below.

template<class R, class F, class T1, class T2, ...., class TN>

unspecified bind(F f, T1 t1, T2 t2, ..., TN tN);

3 Requires: F and Ti shall be CopyConstructible. INVOKE (f, w1, w2, ..., wN) shall be a valid expression for

some values w1, w2, ..., wN.

4 Returns: A forwarding call wrapper g with a nested type result_type defined as a synonym for R. The effect of

g(u1, u2, ..., uM) shall be INVOKE (f, v1, v2, ..., vN, R), where the values and types of the bound

arguments v1, v2, ..., vN are determined as specified below.

5 The values of the bound arguments v1, v2, ..., vN and their corresponding types V1, V2, ..., VN depend on

the type of the corresponding argument ti of type Ti in the call to bind and the cv-qualifiers cv of the call wrapper g as

follows:

— if ti is of type reference_wrapper<T> the argument is ti.get() and its type Vi is T&;

— if the value of std::tr1::is_bind_expression<Ti>::value is true the argument is ti(u1, u2, ...,

uM) and its type Vi is result_of<Ti cv (U1&, U2&, ..., UM&)>::type;

— if the value j of std::tr1::is_placeholder<Ti>::value is not zero the argument is uj and its type Vi is

Uj&;

— otherwise the value is ti and its type Vi is Ti cv &.

这里参数t,v,W来回出现,挺绕的,书读百遍,其义自现

f为要绑定的函数,其参数为 v1,v2,…,vN,类型为V1,V2,…,VN

bind 函数参数为t1, t2, …,tN,类型为T1,T2,…,TN

g 为bind的返回值,参数为参数为u1, u2,…uM,类型为U1, U2,…,UM.

g(u1, u2,…uM)会被转发给f,转发效果相当于f(v1, v2, …,vN)

vi 如下确定

如果对应bind函数参数ti类型为reference_wrapper<T>, 则vi为ti.get(),类型为T&
如果std::tr1::is_bind_expression<Ti>::value为true,即ti是bind的返回值,则vi为ti(u1,u2,…uM),类型为result_of<Ti cv(U1&,U2&,…,UM)>::type
如果std::tr1::is_placeholder<Ti>::value非0,则参数vi为uj,类型为 Uj&
否则vi值为ti,类型为Ti cv&

现在就很明了了,一个bind的返回值r1可以作为另一个bind的参数a1,在转发时转发的是r1(u1, u2,…,uM),即测试的代码是符合标准的.那为什么通不过呢?再加上两个测试,看看bind的返回值类型究竟能否让 is_bind_expression<T>::value为true

template<class T>
bool IsBindResult(const T& v)
{
return std::tr1::is_bind_expression<T>::value;
}
TEST(IsBindResult, BindFuncPtr)
{
ASSERT_TRUE(IsBindResult(std::tr1::bind(Add, std::tr1::placeholders::_1, 2)));
}
TEST(IsBindResult, BindFunctor)
{
ASSERT_TRUE(IsBindResult(std::tr1::bind(std::plus<int>(), std::tr1::placeholders::_1, 2)));
}

编译,运行

结果再次让偶大跃眼镜,居然bind的返回值没能通过is_bind_expression的测试,怎么回事,打开is_bind_expression 的源码来看

template<class _Tx>
struct is_bind_expression
{
static const bool value = false;
};
template<class _Result_type,
class _Ret,
class _BindN>
struct is_bind_expression<
_Bind<_Result_type, _Ret, _BindN> >
{
static const bool value = true;
};

这里对模板作了一个特化,如果bind的模板参数是 _Bind<_Result_type, _Ret, _BindN>类型,则value为true,否则false.

看上去很美,没问题,那为什么测试会失败?难道bind(Add,…)返回的是_Bind类型而 bind(plus<int>(),…)返回的不是?接着看bind实现:

函数指针版

template<class _Rx
_C_CLASS_FARG0
_C_CLASS_ARG0> inline
_Bind<_Rx,
_Rx,
_BINDN<_Callable_fun<_Rx(__cdecl * const)(_FARG0_FARG1)> _C_ARG0_ARG1> >
bind(_Rx(__cdecl * const _Val)(_FARG0_FARG1) _C_ARG0_A0)
{ // bind to pointer to function
typedef _Callable_fun<_Rx(__cdecl * const)(_FARG0_FARG1)> _Callable;
typedef _BINDN<_Callable _C_ARG0_ARG1> _MyBind;
return (_Bind<_Rx, _Rx, _MyBind>(_MyBind(_Val _C_A0_A1)));
}

返回的的确是_Bind类型,

仿函数版

template<class _Fty
_C_CLASS_ARG0> inline
_Bind_fty<_Fty,
_Notforced,
_BINDN<_Callable_obj<_Fty> _C_ARG0_ARG1> >
bind(_Fty _Val _C_ARG0_A0)
{ // bind to UDT
typedef _BINDN<_Callable_obj<_Fty> _C_ARG0_ARG1> _MyBind;
return (_Bind_fty<_Fty, _Notforced, _MyBind>(_MyBind(_Val _C_A0_A1)));
}

返回的却是_Bind_fty类型, 难道_Bind_fty不是_Bind类型导致is_bind_expression返回false?接着看定义

template<class _Ret,
class _BindN>
class _Bind<_Notforced, _Ret, _BindN>
: public _Bind_base<_Ret, _BindN>
{
public:
_Bind(_BindN _B0)
: _Bind_base<_Ret, _BindN>(_B0)
{
}
};
template<class _Fty,
class _Ret,
class _BindN>
class _Bind_fty
: public _Wrap_result_type<(sizeof (::std:: tr1::_Has_result_type((_Fty *)0)) == sizeof (::std:: tr1::_Yes)), _Fty>,
public _Bind_base<_Ret, _BindN>
{
public:
_Bind_fty(_BindN _B0)
: _Bind_base<_Ret, _BindN>(_B0)
{
}
};

果然如此,真相大白.is_bind_expression不认为 bind(functor…)是bind表达式,故会直接将其作为类型为_Bind_fty的参数转发为 logical_and,导致编译出错.

找到错误原因,可以开bug了

Title: std::tr1::bind can't bind a functor as an argument to another functor

How found: manual test

Build version:VC 1010 01019-532-2002102-70993

OS: Windows XP

Repro steps:

Run following code:

Expected:

Code got compiled and test passed. See n1836

Result:

Build break

Note:

The result of std::tr1::bind(std::minus<int>(), std::tr1::placeholders::_1, std::tr1::placeholders::_2) is of type _Bind_fty, which will make is_bind_expression<_Bind_fty>::value = false. Suggestion: modify the return type of bind or change is_bind_expression to make is_bind_expression<_Bind_fty>::value to be true.

提交bug, Ok.

结束了么?还没有,需要编写一个测试来验证这个问题并加到测试列表里去,可是直接写会导致编译出错,怎么办呢?

有办法,

将如下代码保存到一个文件去

#include <iostream>
#include <conio.h>
#include <tchar.h>
int main()
{
auto f0 = std::tr1::bind(std::multiplies<int>(),
std::tr1::bind(std::plus<int>(), std::tr1::placeholders::_1, std::tr1::placeholders::_2),
std::tr1::bind(std::minus<int>(), std::tr1::placeholders::_1, std::tr1::placeholders::_2));
return f0(5, 3);
}

调用cl编译这个文件,如果能得到一个可执行程序并且执行后返回16则测试通过,否则测试失败.

代码就不在这里列举了.

写完测试,添加到daily build的test list中去,什么时候问题解决了从测试结果上就能看出来了.

--------------------------正文的分割线 -------------------------------

注

1 文中写的找bug的过程是直线式的逻辑,思路很清晰,实际我在跟代码的时候就像在一个迷宫里打转,只看见出了错误,不知道什么地方错了,只好用各种手段, 想先找出bind在绑定函数指针时究竟干了什么,再来推理为什么绑定仿函数会出错,根本不是象文中写的那样直接推断到is_bind_expression的问题.

vc2010里tr1库的实现实在不好阅读,满篇全是宏,连函数调用传了几个参数都搞不清楚,我只好先用/E选项把预编译的文件输出出来,在跟踪代码时一边看预处理后的代码一边看汇编,无论哪个都比tr1自己的源代码好读.

不过这一番跟踪下来收获倒也颇丰,

1) 基本清楚了bind的实现,可以另外写篇博客来谈

2) 明白了RVO(返回值优化)的原理.在跟踪bind汇编代码时时发现只要三个参数,却push了四个,调用完成后也是ret 10返回,跟了下去才发现是做的RVO

2 文中用到了ASSERT宏进行测试,也算是对前些天对我这篇金山卫士代码批评评论里大家对ASSERT质疑的一个回应吧.c++库里的assert的作用是及时发现错误反馈给程序员, 会打断程序执行,而测试框架里的ASSERT则是断言测试是否符合预期,把结果传递给测试框架,再由测试框架记录后反馈给程序员.我原来以为在那个上下文都是测试情况下assert的语义应当不言自明的是指后者,没想到还是有很多读者误以为是c++库里的assert.这是我没有把话说清楚,假定自己知道的受众也知道,忽略了背景的区别带来的对同一个名词不同的理解,是我经常犯的一个错误,要努力改正.

3 QA除了写测试用例,用工具和脚本进行测试外还可以在项目过程中参与更多.一个好的QA应当有不弱于Dev的编码能力, 有能力复查Dev设计和编码,直接从中发现问题,以及在测试中发现问题时有能力定位bug源头并给出参考解决方案.QA还要有缜密的思维和想象能力,对边界条件、各种逻辑组合和极端情况能去构造和评估其对功能的影响，因为Dev一般习惯于正常情况下的逻辑,边界情况虽然也会考虑,但还是不会有QA想的全面.遗憾的是目前国内开发团队中这样的QA还是比较少见.

参考资料

本文链接

用vs2010编译kigg 3.0遇到的问题

2010-12-25T14:56:00Z

今天玩kigg时碰到了一些问题,在google帮助下总算搞定了,在这里记录下解决步骤,供日后参考,也给碰到相似问题的朋友一些参考.

kigg用的.NET 3.5, 需要升级到.NET 4.0.因为vs会调用.NET 4.0版的ASP.net compiler,会出现冲突, 还有一个办法是在kigg.web.csproj中指定ASP.NET Compiler路径
<AspNetCompiler VirtualPath="temp" PhysicalPath="$(ProjectDir)\..\Web" ToolPath="C:\Windows\Microsoft.NET\Framework\v2.0.50727" />
有些类是用LinkDemand修饰的,需要去掉,否则运行时会报错.这是为了快速运行起来,没有深究背后的安全性. 比如jQueryScriptManager和reCAPCHA类等
在Web.config System.Web节中加入 <P><httpRuntime requestValidationMode="2.0"/></P> 因为.net 4.0中对HTTP Request validate的处理发生了一些变化,为了和以前的模式保持兼容.否则输入的内容中含有<xxx></xxx>的内容时校验会抛异常.
把Source\SharedFiles里的文件拷贝到app_data目录下.
如果你没有配置email,请如下注释掉Email exception listener
<add switchValue="All" name="FullException">
<listeners>

<add name="TextFileExceptionListener"/>
</listeners>
</add>

参考资料

本文链接

在vs中获得当前所有快捷键代码

2010-12-22T08:14:00Z

ms-help://MS.MSDNQTR.v90.en/dv_vssettings/html/bbfc1243-fa27-45df-9c4b-6bca181132d6.htm

Sub GetAllCommands()
        Dim getCommandsWithSCOnly As Boolean
        Dim cmd As Command
        Dim cmdCollection As Commands
        Dim ow As OutputWindow = DTE.Windows.Item(Constants.vsWindowKindOutput).Object
        Dim owp As OutputWindowPane
        Dim exists As Boolean
        Dim i As Integer

        i = 1
        exists = False

        For Each owp In ow.OutputWindowPanes
            If owp.Name = "Macro Output" Then
                exists = True
                Exit For

            End If
            i = i + 1
        Next

        If exists Then
            owp = ow.OutputWindowPanes.Item(i)
        Else
            owp = ow.OutputWindowPanes.Add("Macro Output")
        End If

        owp.Clear()

        ' Output 1 line per command
        For Each cmd In DTE.Commands
            Dim binding As Object
            Dim shortcuts As String

            shortcuts = ""

            For Each binding In cmd.Bindings
                Dim b As String
                Dim sArray() As String
                b = binding
                shortcuts = shortcuts + b + " "
            Next

            shortcuts = shortcuts.Trim()

            If Not cmd.Name.Trim().Equals("") Then

                owp.OutputString(cmd.Name + vbTab + shortcuts + vbCrLf)
            Else
                owp.OutputString(cmd.Guid.ToString() + ":" + cmd.ID.ToString() + vbTab + shortcuts + vbCrLf)
            End If

        Next
End Sub

本文链接

最近的一些面试感悟

2010-12-16T06:57:00Z

公司一直在招人，可合适的人实在不好招。招了一年多，也就招了五六位。而面试中遇到的各种情况让人唏嘘不已。随便聊聊

1 我们招聘是先在招聘网站上发布信息，然后约投简历的人过来，先做一套题，题做得还可以的当场面试。遇到一些哥们，说自己有N年以上开发经验，不屑于做这些题目。这种人一般直接让HR请回。

如果我招的是管理职位，让你做纯技术问题，或者招C#程序员给做Python问题，那是我们不对。可职位明明是C#高级工程师，做一套C#的题目不是很正常的么。你有能力也没必要通过这种方式来表示，通过解决这些问题来展示你的能力不是更好么。当然如果你是Anders那个级别的人，什么面试都没有意义了。我就找老板亲自出面去请你了。但如果不是，最好还是把心态放得平衡一些。

笔试起的是一个筛选的作用，如果你的简历能够说明你的能力，也可以不用笔试。但是很多人分不清工作经验和能力，十年工作经验并不能保证你的能力就一定达到某个水准。我就碰到许多两三年工作经验的Java程序员不清楚volatile的意思，不知道这个关键字和那个著名的DCL bug的关系。

另外这种情况可能也会让面试官觉得你不好相处与合作，真正有能力的人都是谦逊的，因为他们知道自己不知道，保持一颗谦卑的心才能不断进步。

2 对语言特性掌握不够。.NET3.5,C#3.0出来好些年了，但很多人还是说不出IQueryable和IEnumerable的区别，还有闭包的实现，yield的实现等。工作中用不到不等于你不必去跟踪技术的发展。你不去了解怎么知道这些技术能不能在项目中用上。另外对技术的了解不是说会照着turorial写几个例子就是OK了,实现不说完全了解，也要知道个大概。一个合格的C#程序员JIT, GC,yield, lambda和闭包的关系,Linq中的表达式树等是一定要清楚的，如果你新技术跟进足够快的话DLR中dynamic的实现，TPL库也需要了解，如果能聊下一版C#可能出现的新特性，会更让人刮目相看的。同样，一个C++程序员如果不了解stl,boost, C++0x也不是很妥。你可以不用，但是需要知道有这些优秀的工具供你使用。

3 对阅读优秀代码不够重视。阅读优秀代码是很好的一种学习方式。操千曲而后晓声，观千剑而后识器。如果只是停留于照着一门技术的sample代码或者网上流传的入门教程的地步，显然是不够的。这不是对写入门教程的作者不敬，我很尊重那些原创或者翻译技术入门教程的同学，也从各种入门教程学了很多东西。但一门技术总会有各种教程难以覆盖的细节和无法一一列举的惯用法。C++可以拿来写过程式的代码也能做元编程和函数式编程，ruby中不用||=, each惯用法而用if, for, ASP.NET MVC中不用URLHelper生成url而在view中Html.ActionLInk字符串等，不一道哉。这些都是入门教程没办法教给你的，但可以从优秀的开源项目中去学习。SourceForge, Google Code, CodePlex应该在你的收藏夹中。

4 对其它基础知识掌握不扎实。操作系统、数据库、数据结构和算法是一定要掌握的。一个简单的数据库问题，User表包含UserName NVARCHAR(50) NOT NULL, UserType INT NOT NULL。如何保证在UserType=1时UserName不重复，很多人都告诉我先select,判断username不存在再插入，当我问起如何处理并发时就告诉我用存储过程，把这个逻辑放到事务中去。可见很多人没有清楚理解事务能做什么，不能做什么，并且在工程上考虑不全面，让我很郁闷。当然术业有专攻，如果是做算法或者桌面应用的程序员，数据库不了解是可以接受的。但天天做业务逻辑的程序员不懂SQL, 不了解事务、隔离级别，索引实现与性能调优就说不过去了。但无论哪个方向的程序员，数据结构一定需要有基本的了解。不讨论RB Tree, AVL Tree, Suffix Tree这些较复杂的东西，简单的数组，栈，队列，查询排序啥的应该和九九表一样熟悉。否则，除了做简单的堆砌业务逻辑，复杂一点的东西就很难摆平了。

5 逻辑推理能力有待提高。笔试中一般会有一两个逻辑问题，这种问题虽然不直接对应日常的开发工作，但能体现出一个人的解决问题能力，在交流中还能体现出沟通能力。这篇文章说得更清楚。http://blog.sina.com.cn/s/blog_4caedc7a0100nlx2.html。

6 对工具掌握不够。很多好几年工作经验的人不会用unit test，不会查看code coverage和做Profile,设断点只会F9，编辑代码只会用IDE. 工欲善其事，必先利其器。用好工具可以成倍的提高你的生产率，《程序员修炼之道》和《卓有成效的程序员》都是好书。

聊了这么多面试中遇到的问题，再聊聊技术学习。以下纯属个人见解，不构成指导意见。我不是神人大牛，只是业余写代码的QA, 看法难免错漏，欢迎批评指正。

1 向经典而不是宝典学习。

今年初学Java,办法就是装上JDK和Eclipse,看JDK中concurrent和Collection相关的源代码，然后看了看Spring中IOC实现，cglib和jdk proxy的区别，再用DBUnit和spring中的test框架给组里搭了一个小的数据库测试工具，明白了JUnit的运行原理和spring test中事务是如何实现的。这些东西书店里的各种宝典是不会教给你的。

2 注重原理而非操作手册。

远离插图多，操作多，原理少，剖析少的书。很多东西都是易学难精，因为难精，才更有价值，更需要精。一本 SQLServer书，一步步告诉你怎么在SSMS中创建数据库，创建表，创建index,这就算了，随便找个人3天都能会，3天以后就不需要再看的东西就不要浪费这钱买书了。不如攒下来给女朋友买个ipad啥的更能发挥作用。一定要找像《Iniside Microsoft SQL Server 2005》这种明明白白告诉你一条SQL语句从解释，优化来执行的全过程，一张表是怎么样存储在硬盘上的好书。(非书托)

3 关注第一手材料.

多加入一些邮件组或者订阅一些blog,如VC++ team, C# team, msdn magazine, asp.net等（最近主要关注.NET,只列出了相关的内容)。第一手资料总比第二手新鲜和精确。这两天捣鼓VS2010的C++,去把VC team的blog翻了一遍，受益匪浅。

4 重视基本功

《深入理解计算机系统》，《算法导论》如果能看明白一半，找工作已经不是问题了，什么框架，什么经验都是浮云了。

5 关注新技术

今天的小众技术，明天可能就是主流。比别人先行一步，可能就掌握了先机。但要注意技术的应用前景和生命周期。很多MFC,vxd的拥趸深有体会。还有一点，很多技术都是相通的，用过rails后，再看asp.net mvc,很多时候都会有似曾相似之感。

6 重视工具

工具是双手的延伸，使用得到能为你节省无数时间。会一个条件断点，就能给你节省许多中断，查看，运行，再中断，查看...的时间。更不用说其它工具和工具组合能带来的提高。《程序员修炼之道》和《卓有成效的程序员》里说得很清楚，就不拾人牙慧了。

本文链接

这两天被vs2010的std::tr1::bind郁闷了

2010-12-08T13:36:00Z

    std::tr1::function<bool(bool)> f4 =
        std::tr1::bind(
            std::logical_and<bool>(),
            std::tr1::bind(std::logical_not<bool>(), std::tr1::placeholders::_1),
            true);

想在vs2010里玩一玩function programming,却被郁闷了,又发现了一个别人发现过的bug

A bug about std::tr1::bind

由 Microsoft 在 2009/8/7 18:33 发送

Hi,

Thanks for reporting this bug. Unfortunately, we have resolved it as Won't Fix for VC10. Our implementation is fragile when it comes to nested bind(), and we'll need to devote significant time to fixing it - time we don't have for VC10. (I can't promise anything, but I hope to be able to rewrite bind()'s implementation when we get variadic templates.)

The good news is that lambdas in VC10 supersede bind() in 99% of cases. Lambdas offer much more natural syntax (especially compared to nested bind()) and greater efficiency, since the optimizer can inline lambdas but has difficulty with bind()'s functors.

Here's an example that expresses your bind() functor as a lambda (doing something slightly different with it, but the functor has the same behavior):

C:\Temp>type meow.cpp
#include <algorithm>
#include <iostream>
#include <iterator>
#include <ostream>
#include <vector>
using namespace std;

int main() {
    vector<int> v;
    v.push_back(2);
    v.push_back(4);
    v.push_back(6);
    v.push_back(8);
    v.push_back(1);
    v.push_back(3);
    v.push_back(5);
    v.push_back(7);
    v.push_back(9);

    vector<int> dest;

    copy_if(v.begin(), v.end(), back_inserter(dest), [](int n) { return n >= 3 && n <= 8; });

    for_each(dest.begin(), dest.end(), [](int n) { cout << n << " "; });
    cout << endl;
}

C:\Temp>cl /EHsc /nologo /W4 meow.cpp
meow.cpp

C:\Temp>meow
4 6 8 3 5 7

Until you get VC10, remember that handwritten functors are always an alternative to using bind().

If you have any further questions, feel free to E-mail me at stl@microsoft.com .

Stephan T. Lavavej
Visual C++ Libraries Developer

由 Microsoft 在 2009/4/22 23:36 发送

Thanks for your feedback.

We are escalating this issue to the appropriate group within the Visual Studio Product Team for triage and resolution. These specialized experts will follow-up with your issue.

Thank you,
Visual Studio Product Team

只好换boost或者lambda

本文链接