Brain Dumps

　　不知从何时起，“压力山大”成了都市白领自嘲的流行语。“有压力时觉得累，没压力时觉得可怕”，“加班压力大，不加班压力更大”。 　　最新的一项“2012关爱职场白领、关注白领健康调查”显示，2/3的受访者认为自己的身体状况处于亚健康状态，危害身体健康的主要因素中，工作压力、环境污染和缺乏锻炼位列前三位。 　　这项调查由媒体和知名企业共同进行，采用的是计算机辅助电话随机抽样的调查方式，选择了北京、上海、广州、成都、西安、长沙和沈阳7个代表性的城市，调查的对象是20岁到60岁之间、中等学历以上、主要从事脑力劳动的办公室白领，成功完成的样本量是1000人。 　 　另外一家世界知名调查机构也得出过类似结论：中国内地上班族在过去一年内所承受的压力，位列全球第一。在全球80个国家和地区的1.6万名职场人士中， 认为压力高于去年的，中国内地占75%，香港地区占55%，分列第一和第四，都大大超出全球的平均值48%。其中，上海、北京分别以80%、67%排在这 一调查结果城市排名的前列。 　　国家行政学院公共管理学院教师胡颖廉分析，人们之所以感到压力大，一大原因来自物质保障方面。由于我国社 会保障体系总体有待完善，人们对医疗、养老、住房和子女教育等问题缺乏稳定感，因此，努力将未来收益“折现”到当前实现，其代价就是透支身心健康。“另一 方面，压力也来自精神方面，当前社会存在一些不公平现象，贫富差距扩大，不少人产生"相对被剥夺感"，群体性焦虑情绪严重，这加剧了急功近利、肤浅急躁的 社会氛围。”胡颖廉说。 　　一项内容为“月薪多少会让你在相应的城市生活不惶恐”的调查显示，上海、北京等一线城市需9000元左右，成都、大连等二线城市则在5000元上下浮动。 　 　当压力不断增加，相当一部分人所感觉到的焦虑，就从一种普遍的情绪体验，变成精神障碍疾病。有专家指出，适当的压力可以产生动力，但压力过大则会产生负 面作用。在20世纪七八十年代经济迅速发展的日本，过度疲劳曾造成大量中青年人猝死，如今，中国已超越日本成为“过劳死”大国。有统计显示，巨大的工作压 力导致我国每年过劳死亡的人数达60万人，越来越多的都市白领处于“亚健康”状态。 　　“导致抑郁症发病的外界压力往往不是突如其来的很急骤的一次性的打击，经常是慢性的，持续的，不可预见的压力，这和我们很多白领的工作

据说这是在美国一个论坛上发现的一个美国人评价中国人的普通贴子。 ======================================= 中国人缺乏诚信和社会责任感。 中国人不了解他们作为社会个体应该对国家和社会所承担的责任和义务。 普通中国人通常只关心他们的家庭和亲属，中国的文化是建立在家族血缘关系上而不是建立在一个理性的社会基础之上。中国人只在乎他们直系亲属的福址，对与自己毫不相关的人所遭受的苦难则视而不见。 毫无疑问，这种以血缘关系为基础的道德观势必导致自私，冷酷，这种自私和冷酷已经成为阻碍中国社会向前发展的最关键因素。 中国人所说的政治除了欺骗和背叛没有其它东西。 中国从来就没有成为一个法制社会，因为中国人的思维方式与守法行为格格不入。中国人老想走捷径。他们不明白这样一个事实：即成就来自于与努力工作和牺牲。 中国人倾向于索取而不给予。他们需要明白一个道理：生活的真蒂不在于你你索取多少而在于你能给予社会和你的人类同胞多少。 大多数中国人从来就没有学到过什么是体面和尊敬的生活意义。 中 国人普遍不懂得如何为了个人和社会的福址去进行富有成效的生活。潜意识里，中国人视他们的生活目的就是抬高自己从而获得别人的认知。这样一来，一个人就会 对“保有面子” 这样微不足道欲望感到满足。“面子”是中国人心理最基本的组成部分，它已经成为了中国人难以克服的障碍，阻碍中国人接受真理并尝试富有意义的生活。 这 个应受谴责的习性使得中国人生来就具有无情和自私的特点，它已成为中国落后的主要原因。中国人没有勇气追求他们认为正确的事情。首先，他们没有从错误中筛 选正确事物的能力，因为他们的思想被贪婪所占据。再有，就算他们有能力筛选出正确的事情，他们也缺乏勇气把真理化为实践。 中国人习惯接受廉 价和免费的事物，他们总是梦想奇迹或者好运，因为他们不愿意付出努力，他们总想不劳而获。很少有中国人明白一个事实，就是威望和成就是通过一步步努力的工 作和牺牲实现的，不付出就没有所得。简单来说，如果是为了谋生，那一个人只有去索取；但如果是为了生活，一个人必须要去奉献。 由于在贫穷的环境下生长并且缺少应有的教育，大多数中国人不懂得优雅的举止和基本的礼貌。他们中的大多数人着装笨拙粗鄙却不感到害羞。 他们在青少年时所受的教育就是如何说谎并从别人那里索取，而不是去与别人去分享自己的

发信人: Dreamer (不要问我从哪里来), 信区: Dreamer 标  题: 出国13年 发信站: BBS 未名空间站 (Fri Oct 26 01:30:21 2012, 美东) 99年：跟远距离介绍的男友去日本，上研究生，准备考试，打工练语言。 00年：考上大学院，打工，做实验。发现男友是个啃老族，常吵架，然后分手。自己专 心考过日语一级。 01年：拿到奖学金，做实验，少量打工积累语言，直到拿到大企业的工作内定。 02年：硕士毕业，论文发表到不错的英文刊物。春开始到大企业工作，500万日元一年。 03-04年：工作，之外很封闭自己，单着。感觉日本不能长久呆，文化太郁闷。匆忙 考T。 05年：美国烂校的硕士奖学金，秋天辞职来美入学，冬天碰上后来成老公的男友。 06年：有点怀恋日本的安定工作。生活上常和男友磨合，观念不同。但他不交绿卡申请 H1就到期要离境，匆忙秋天结婚。 07年：我混学位，渐渐改变在日本养成的封闭性格。春天老公首付买房子，我年底毕业 找到工作。 08年：工作开始不顺，半年后进入正轨。跟着老公拿到绿卡。老公高校快速评到教授收 入9万，我6万。 09年：工作，我的收入负责存钱，老公收入用来开销还房贷。想要孩子，终于年底怀孕。 10年：留职停薪，在家安胎，秋儿子出生，和老公两人带。年底被公司召回上半职班。 11年：工作，之外带孩子。秋天恢复全职工作，7-8万。 12年：我付首付买两个投资房，工资收入8万，老公约10万。想要老二。。。 中部大农村，就这样过着日子。。。

Top 11 Amazing Health Benefits of Sleep 1. Improves your memory 2. Extends your lifespan 3. Boosts your creativity 4. Strengthens your immune system 5. Helps your body heal itself 6. Improves your physical performance 7. Sharpens your attention 8. Reduces your stress 9. Reduces your risk for depression 10. Helps you lose weight 11. Makes you more alert

【转载】总理家人隐秘的财富 http://cn.nytimes/article/china/2012/10/26/c26princeling/ 《纽约时报》----（全文翻译） DAVID BARBOZA 报道 2012年10月26日       上海——中国总理温家宝的母亲杨志云曾是东北的一名教师，他的父亲在毛泽东 时代曾被派去养猪。去年，温家宝在一次讲演时说道，他的童年打着“贫穷、混乱和饥 饿”的烙印。 然而，公司与监管记录显示，现年90岁的杨志云不仅不再贫穷，而且绝对富裕。记录显 示，仅她名下对一家大型中国金融企业的一项投资就曾在5年前价值1.2亿美元（约合7. 6亿元人民币）。       没人知晓丈夫已经去世的杨志云是如何积累这笔财富的。但这一过程发生在她儿 子被提拔进统治中国的精英阶层之后。温家宝先在1998年升任国务院副总理，五年后他 出任总理。       《纽约时报》的调查显示，温家宝担任领导职务期间，他的很多亲属变得极为富 有，其中包括温家宝的儿子、女儿，弟弟及妻弟。对公司与监管记录的调查显示，在总 理的亲属中，有些人的生意风格十分强势，他们掌控了价值不低于27亿美元（约合170 亿元人民币）的财富。       很多情况下，这些亲属的名字都掩藏在多重合伙人和朋友、同事、商业伙伴与远 亲的投资载体背后。此番财务解析细致而不同寻常地揭示出，在经济高速发展、政府影 响和私人财富重叠交错的中国，拥有政治人脉的人物是如何利用自己沟通政商的能力谋 取利益。       资料显示，与大多数中国的新企业不同，这个家族的生意不时从国有企业获得金 融支持，其中包括中国最大的电信运营商，中国移动和中国电信。其他时候，这些企业 得到了一些亚洲最富有的商业巨头的支持。《纽约时报》发现，温家宝的亲属在银行、 珠宝公司、度假村、基础设施项目和电信公司中持有股份，其中部分 股权是通过离岸 机构持有的。       他们的资产包括位于北京的一处别墅开发项目、连接上海和杭州的收费公路的部 分路段、一家靠近香港的飞机租赁服务公司、一家曾参与修建包括标志建筑“鸟巢”( Bird’s Nest)在内的一些北京奥运场馆的公司，以及平安保险，世界上最大的金融服 务公司之一。       今年70岁的温家宝，作为一个仍然严重依靠政

Lists of DZero candidate looking for postdoc and tenure track jobs Date: 30-SEP-2012 11:32 Expires: 15-OCT-2012 11:32 Dear DZero postdocs and students, with new season of hirings for tenure track and postdoc positions starting the experiment spokes are often asked for a list of candidates from DZero. We keep such list and update it periodically. If you are looking or planning to look for tenure track (both Labs and Universities) or postdoctoral position in the next 12 months, please, send us a brief E-mail with summary of your interests. Please, remember about orientation lectures this Wednesday, October 3 at noon for tenure track candidates and next Wedensday, October 10 at noon for postdoctoral candidates. Both lectures are in the Hurricane deck and will be available on video. Thank you, Gregorio and Dmitri.

• If you need to choose between regular expressions and writing a loop, choose regular expressions. The regular expression engine is compiled in C and runs natively on your computer; your loop is written in Python and runs through the Python interpreter. • If you need to choose between regular expressions and string methods, choose string methods. Both are compiled in C, so choose the simpler one. • General−purpose dictionary lookups are fast, but specialtiy functions such as string.maketrans and string methods such as isalpha() are faster. If Python has a custom−tailored function for you, use it. • Don't be too clever. Sometimes the most obvious algorithm is also the fastest. • Don't sweat it too much. Performance isn't everything. I can't emphasize that last point strongly enough. Over the course of this chapter, you made this function three times faster and saved 20 seconds over 1 million function calls. Great. Now think: over the course of those million function

>>> import timeit >>> t = timeit.Timer("soundex1a.soundex('Pilgrim')", "import soundex1a") >>> t.timeit() 10.787981033325195 >>> t.repeat() [10.59093189239502, 10.520797967910767, 10.513777017593384] >>> t.repeat(3, 2000000) [22.054033041000366, 21.18790602684021, 21.265258073806763] >>> t.repeat(5, 2000000) [21.35662817955017, 21.061805963516235, 21.77834391593933, 22.74197006225586, 22.04066300392151] The timeit module defines one class, Timer, which takes two arguments. Both arguments are strings. The first argument is the statement you wish to time; in this case, you are timing a call to the Soundex function within the soundex with an argument of 'Pilgrim'. The second argument to the Timer class is the import statement that sets up the environment for the statement. Internally, timeit sets up an isolated virtual environment, manually executes the setup statement (importing the soundex modu

Timing short pieces of code is incredibly complex. How much processor time is your computer devoting to running this code? Are there things running in the background? Are you sure? Every modern computer has background processes running, some all the time, some intermittently. Cron jobs fire off at consistent intervals; background services occasionally "wake up" to do useful things like check for new mail, connect to instant messaging servers, check for application updates, scan for viruses, check whether a disk has been inserted into your CD drive in the last 100 nanoseconds, and so on. Before you start your timing tests, turn everything off and disconnect from the network. Then turn off all the things you forgot to turn off the first time, then turn off the service that's incessantly checking whether the network has come back yet, then ... And then there's the matter of the variations introduced by the timing framework itself. Does the Python interpreter cache meth

Soundex was a method used in the early 20th century for categorizing surnames in the United States census. It grouped similar−sounding names together, so even if a name was misspelled, researchers had a chance of finding it. Soundex is still used today for much the same reason, although of course we use computerized database servers now. Most database servers include a Soundex function. There are several subtle variations of the Soundex algorithm. This is the one used in this chapter: 1. Keep the first letter of the name as−is. 2. Convert the remaining letters to digits, according to a specific table: ♦ B, F, P, and V become 1. ♦ C, G, J, K, Q, S, X, and Z become 2. ♦ D and T become 3. ♦ L becomes 4. ♦ M and N become 5. ♦ R becomes 6. ♦ All other letters become 9. 3. Remove consecutive duplicates. 4. Remove all 9s altogether. 5. If the result is shorter than four characters (the first letter plus three digits), pad the result with trailing zeros. 6. if the result is longer than four

Let's start here: are you sure you need to do it at all? Is your code really so bad? Is it worth the time to tune it? Over the lifetime of your application, how much time is going to be spent running that code, compared to the time spent waiting for a remote database server, or waiting for user input? Second, are you sure you're done coding? Premature optimization is like spreading frosting on a half−baked cake. You spend hours or days (or more) optimizing your code for performance, only to discover it doesn't do what you need it to do. That's time down the drain. This is not to say that code optimization is worthless, but you need to look at the whole system and decide whether it's the best use of your time. Every minute you spend optimizing code is a minute you're not spending adding new features, or writing documentation, or playing with your kids, or writing unit tests. Oh yes, unit tests. It should go without saying that you need a complete set of unit

• Treating functions as objects, storing them in lists, assigning them to variables, and calling them through those variables. • Building dynamic functions with lambda. • Building closures, dynamic functions that contain surrounding variables as constants. • Building generators, resumable functions that perform incremental logic and return different values each time you call them. Adding abstractions, building functions dynamically, building closures, and using generators can all make your code simpler, more readable, and more flexible. But they can also end up making it more difficult to debug later. It's up to you to find the right balance between simplicity and power.

import re def rules(language):     for line in file('rules.%s' % language):         pattern, search, replace = line.split()         yield lambda word: re.search(pattern, word) and re.sub(search,         replace, word) def plural(noun, language='en'):     for rule in rules(language):         result = rule(noun)         if result: return result if __name__ == '__main__':     import sys     if sys.argv[1:]:         print plural(sys.argv[1])     else:         print __doc__ for line in file(...) is a common idiom for reading lines from a file, one line at a time. It works because file actually returns a generator whose next() method returns the next line of the file. No magic here. Remember that the lines of the rules file have three values separated by whitespace, so line.split() returns a tuple of 3 values, and you assign those values to 3 local variables.   And then you yield. What do you yield? A function, built dynamically with lambda, that is actually a c

>>> def make_counter(x): ...     print 'entering make_counter' ...     while 1: ...         yield x ...         print 'incrementing x' ...         x = x + 1 ... >>> counter = make_counter(2) >>> coutner Traceback (most recent call last):   File " ", line 1, in NameError: name 'coutner' is not defined >>> counter >>> counter.next() entering make_counter 2 >>> counter.next() incrementing x 3 >>> counter.next() incrementing x 4 The presence of the yield keyword in make_counter means that this is not a normal function. It is a special kind of function which generates values one at a time. You can think of it as a resumable function. Calling it will return a generator that can be used to generate successive values of x. To create an instance of the make_counter generator, just call it like any other function. Note that this does not actually execute the function code. You can tell this beca

import re import string def buildRule((pattern, search, replace)):     return lambda word: re.search(pattern, word) and re.sub(search, replace,   word) def plural(noun, language='en'):     lines = file('rules.%s' % language).readlines()     patterns = map(string.split, lines)     rules = map(buildRule, patterns)     for rule in rules:         result = rule(noun)         if result: return result if __name__ == '__main__':     import sys     if sys.argv[1:]:         print plural(sys.argv[1])     else:         print __doc__ You're still using the closures technique here (building a function dynamically that uses variables defined outside the function), but now you've combined the separate match and apply functions into one. Our plural function now takes an optional second parameter, language, which defaults to en. You use the language parameter to construct a filename, then open the file and read the contents into a list. If language is en, then you&

>>> def foo((a, b, c)): ...     print c ...     print a ...     print b ... >>> parameters = ('apple', 'bear', 'cat') >>> foo(parameters) cat apple bear The proper way to call the function foo is with a tuple of three elements. When the function is called, the elements are assigned to different local variables within foo.

import re def buildMatchAndApplyFunctions((pattern, search, replace)):     matchFunction = lambda word: re.search(pattern, word)     applyFunction = lambda word: re.sub(search, replace, word)     return (matchFunction, applyFunction) patterns = \   (     ('[sxz]$', '$', 'es'),     ('[^aeioudgkprt]h$', '$', 'es'),     ('(qu|[^aeiou])y$', 'y$', 'ies'),     ('$', '$', 's')   ) rules = map(buildMatchAndApplyFunctions, patterns) def plural(noun):     for matchesRule, applyRule in rules:         if matchesRule(noun):             return applyRule(noun) if __name__ == '__main__':     import sys     if sys.argv[1:]:         print plural(sys.argv[1])     else:         print __doc__a buildMatchAndApplyFunctions is a function that builds other functions dynamically. It takes pattern, search and replace (actually it takes a tuple, but more on that in a minute), and you can build the match fun

import re rules = \   (     (      lambda word: re.search('[sxz]$', word),      lambda word: re.sub('$', 'es', word)      ),     (      lambda word: re.search('[^aeioudgkprt]h$', word),      lambda word: re.sub('$', 'es', word)     ),     (      lambda word: re.search('[^aeiou]y$', word),      lambda word: re.sub('y$', 'ies', word)     ),     (      lambda word: re.search('$', word),      lambda word: re.sub('$', 's', word)     )   )     def plural(noun):     for matchesRule, applyRule in rules:         if matchesRule(noun):             return applyRule(noun) if __name__ == '__main__':     import sys     if sys.argv[1:]:         print plural(sys.argv[1])     else:         print __doc__ This is the same set of rules as you defined in stage 2. The only difference is that instead of defining named functions like match_sxz and apply_sxz, you have "inlined" those function de

import re def match_sxz(noun):     return re.search('[sxz]$', noun) def apply_sxz(noun):     return re.sub('$', 'es', noun) def match_h(noun):     return re.search('[^aeioudgkprt]h$', noun) def apply_h(noun):     return re.sub('$', 'es', noun) def match_y(noun):     return re.search('[^aeiou]y$', noun)         def apply_y(noun):     return re.sub('y$', 'ies', noun) def match_default(moun):     return 1 def apply_default(noun):     return noun + 's' rules = ((match_sxz, apply_sxz),          (match_h, apply_h),          (match_y, apply_y),          (match_default, apply_default)          ) def plural(noun):     for matchesRule, applyRule in rules:         if matchesRule(noun):             return applyRule(noun) if __name__ == '__main__':     import sys     if sys.argv[1:]:         print plural(sys.argv[1])     else:         print __doc__    Using a for loop, you can pull out the match and apply

发信人: Dreamer (不要问我从哪里来), 信区: Dreamer 标  题: 俺也说说过去十年 发信站: BBS 未名空间站 (Tue Oct 23 01:05:21 2012, 美东) 权当流水帐，其实是十几年。 本科尼玛完全就是脱线的风筝，没有家人约束，基本被运动和电子游戏统治了生活。找 了女朋友，青涩，毕业分手，无奈。 苦逼的专业让我后来意识到前途的黑暗，下定决心用黑夜给我的黑色的眼睛寻找光明。 靠，找来找去，好像当时只有上研似乎是一丝光亮。。。 2003年，女友劈腿，痛苦的想办法离开。硕士毕业，申请到欧洲第三国phd。第一次见 识资 本主义，擦，尼玛原来资本主义也不是课本上老师口中的那么回事啊。那种震撼给我那 幼小的心灵留下了深深的创伤。。。 Research折磨着痛苦的我，每周日的懒觉就真是奢望。回头一想真他妈想骂娘啊。 同年认识LD。哈喇子。。。。。。 2005年和LD走在一起，幸福快乐着。朋友越来越多，想法还是很单纯，尽快毕业吧。。 2007年博士毕业，结婚。研究还不错。 后来两年在同一个国家博后，发表研究论文几篇。双方家里老人身体欠佳，不能尽孝， 内心深感歉疚。拿到第三国身份。孩子出生，ld家人全力支持，非常感激，无以回报。 Ld工作努力，前景也有，但不明朗。也无奈着，这个地方没有我苦逼专业的用武之地， 难道转行？痛苦和煎熬。。。 2009年美国东北部牛校博后机会，决定来美国吧。Ld牺牲挺多。我自己还是看不来自己 的路。来之前根本没想呆在美国，准备回到第三国学校做研究，当时这么想的。来了， 对美国生活没概念，绿卡是怎么回事？哎，你问谁呢老兄，问我么？买了第一辆车。 2010，研究，再就是跟领导小小出游一下。年底投出唯一一份faculty申请之后，终于 认清了自己的兴趣，不是faculty。真是loser啊。。。。这一年，是我们转变想法，开 始想要留在美国的一年。 2011，找美国的工业界的工作，意识到绿卡的重要性。第一次知道了EB1。准备，审稿 ，申请。同时投出几十份简历。电话面试陆续开始有。领导一直很上进，成功转行，做 了转行后的第一份part time的工。孩子一直送幼儿园。年底拿到卡。 2012，上半年，领导找到一个稳定的工，但是在很远的州，在我的鼓励下，

应用程序接口（英语：Application Programming Interface，简称：API），又称为应用编程接口，就是软件系统不同组成部分衔接的约定。由于近年来软件的规模日益庞大，常常会需要把复杂的系统划分成小的组成部分，编程接口的设计十分重要。程序设计的实践中，编程接口的设计首先要使软件系统的职责得到合理划分。良好的接口设计可以降低系统各部分的相互依赖，提高组成单元的内聚性，降低组成单元间的耦合程度，从而提高系统的维护性和扩展性。 目录     1 概要     2 API种类         2.1 API in object-oriented languages         2.2 API libraries and frameworks         2.3 API and protocols         2.4 API and device interfacing         2.5 Web APIs     3 API的开发样例代码     4 参考文献     5 外部链接     6 参见 概要 应用程序接口为：“‘电脑操作系统（Operating system）’或‘程序库’提供给应用程序调用使用的代码”。其主要目的是让应用程序开发人员得以调用一组例程功能，而无须考虑其底层的源代码为何、或理解其内部工作机制的细节。API本身是抽象的，它仅定义了一个接口，而不涉入应用程序如何实现的细节。 例如，图形库中的一组API定义了绘制指针的方式，可于图形输出设备上显示指针。当应用程序需要指针功能时，可在引用、编译时链接到这组API，而运行时就会调用此API的实现（库）来显示指针。 应用程序接口是一组数量上千、极其复杂的函数和副程序，可让程序员做很多任务作，譬如“读取文件”、“显示菜单”、“在视窗中显示网页”等等。操作系统的API可用来分配存储器或读取文件。许多系统应用程序借由API接口来实现，像是图形系统、数据库、网络Web服务，甚至是联机游戏。 应用程序接口有诸多不同设计。用于快速执行的接口通常包括函数、常量、变量与数据结构。也有其它方式，如通过解释器，或是提供抽象层以屏蔽同API实现相关的信息，确保使用API的代码无需更改而适应实现变化。 应用程序接口经常是软件开发工具包（SDK）的一部分。 API种类 API又分为（Window

First, let’s talk about what not to do. If you got a letter like this would you run out and hire this person? Dear Mr./Ms/Mrs., Thank you for talking to me about the job at XYZ Company. I know I made a big impression on you and you are still overwhelmed that a person of my caliber would even seek this position. I can tell this because you have not yet called to make me a rock bottom offer that we will need to negotiate up just to reach my level of desire. Sincerely, Moss Stromboli New Executive I don’t think so. However the follow up letter after an interview can be the nail that either cinches an offer or one that seals the coffin. The one above would not seal any deal. So what should you put in a thank-you letter after a job interview? sample thank you letter after interviewFirst, send a real thank you letter. Not an email. Thank you letters are generally more effective when sent in the mail and are at the very least hand written. You can have the letter

发信人: TheBigSlick (Ivan), 信区: JobHunting 标  题: Re: onsite感觉很好，还是被拒 发信站: BBS 未名空间站 (Wed Sep 26 00:51:57 2012, 美东) Sorry to say that you made a big mistake. You seem lacking experiences. A new graduate? First, why you told hiring manager you had offers (especially from a competitor) during interview in the fist place? Of course, they can reject you based on that alone. Why? From hiring manager point of view, hiring you most likely will be a waste of time. They will think if they give you the offer, you will just use it as leverage and ask companies entering a bidding war, which they most definitely don't want to see. Furthermore, if I were the hiring manager, I want to hire somebody who want the job, not somebody who consider coming to working for me a "tough decision" . You don't firmly want to come there, from their point of view. Just treat interview as a dating process, imagine when you date some girl, if she tell you "oh, tell the truth,

发信人: redsohutu (世界很远心很近), 信区: JobHunting 标  题: 第一次onsite 发信站: BBS 未名空间站 (Fri Aug 17 12:58:40 2012, 美东) 提前二十分钟到，最后却拖了一个多小时才走。不知道是我太能说了呢，还是大家太爱 跟我聊天了。 明明胸有成足，一点都不担心，却还是前一天晚上没睡好。还好只是半天的时间。真难 想象若是排满一天的面试如何捱得过去。 过程很平常，做presentation（问的问题不难，他们不会比你懂得多），跟其他组的一 个头talk（不懂这个安排，是其他部门的代表？），跟HR manager talk，跟小老板 talk，跟这个组的人talk，最后跟大老板talk。 反正就一直在那个会议室里，一伙儿换拨人来跟我谈。竟然每一轮都有问这几个问题： 1. 谈谈你team work的经历啊，适不适合之类的 2. 你的优缺点 3. 你如何看你五年后的发展（个人觉得这个问题的回答比较难把握分寸，对自己组员 会谦虚一点，对HR会不谦虚一点，对老板们两者兼备） 4. 如果team里有人不合如何处理（或者类似的，被我转化成confliction来谈了） 5. 你如何定义successful, happy等等 跟一组人meet的时候会稍微tough一点，因为你说的每句话某个词都会冷不丁被其中某 个人抓住追问。而且你自己还要别忘了活跃气氛。 小公司，别说饭了，水都没得准备的。幸亏自己带了瓶水，话说太多，喝完后小老板跑 去帮我fill up，小感动一把。 走的时候HR manager说可以帮我把thank you note转给大家，晚上回来后就发了一封信 署名给所有见过的人说谢谢。到现在还没人回信，是不是没戏了？而且我知道其他竞争 者好像还挺牛的，比如有从大公司退下来的。反正我自己尽力了，而且确实就表现得很 好，没啥好遗憾的。不管了，自己该做啥做啥去。 自己生物菜鸟，这点小经验跟人相比实在不值一提。只是在版上受益良多，该回来汇报 一下。 --

发信人: nikeing (inging), 信区: JobHunting 标  题: (更新)刚接到HR电话。 急问onsite面试完了以后写给几个面试者的 关键字: 面试，感谢信 发信站: BBS 未名空间站 (Wed Aug 15 11:29:09 2012, 美东) 如题，onsite归来，感觉很没谱，想再写一下感谢信表达一下自己的强烈兴趣。但是当 时有四个人面，我实在写不出四份感谢信，请问能写一样的吗？他们四个人不会无聊到 拿来比对吧？ 先谢谢啦 更新： HR刚才打电话过来了。她问了我对昨天面试和对公司的感 觉，然后又问我的身份。这个比较麻烦，我现在刚开始opt extension,但是只是收到了 i797-c receipt,还没收到正式的EAD卡。而且为了能申请extension,我上个月底去学校 找了个part time的RA的工作，但是这个工作我并没有写到简历上，昨天也没有提起。 她刚才还问我是不是现在没工作，我就照实说在学校做一份part time的工作。 最后又问有没有别的offer或者是final interview. 我说有interview但是还不到final round. 挂了电话她发了封邮件给我，说如果我有什么变动的话马上 让她知道。我就立马给她的邮箱发了封邮件，详细阐述了OPT的开始和截至日期，还有 稍微解释了一下这份part time的工作，为什么我没写在简历上。现在好紧张，希望她 能理解吧。千万别觉得我是在故意隐瞒什么。哎呀呀呀。。。 虔诚地求个祝福吧，真的很想要这份工作，工作地点，公司氛围还有工作内容都很喜欢 ，拜托大家给个祝福吧 发信人: obsl (豁然开朗), 信区: JobHunting 标  题: Re: (更新)刚接到HR电话。 急问onsite面试完了以后写给几个面试者 发信站: BBS 未名空间站 (Thu Aug 16 20:48:47 2012, 美东) 我当时是把每个人的邮箱给猜出来了，都写了，但是内容不一样，不用太长，写了感觉 还是好，表示你对这个工作有兴趣，后来只有我感觉不好的面试官给我回了信，其他人 都没回，然后我就开始郁闷，结果还是拿到offer了。 写不写是态度问题，回不回和雇你与否没关系。

发信人: lovexyz (Call me maybe), 信区: JobHunting 标  题: 作为内部人来说说Amazon onsite的必杀技兼推荐 发信站: BBS 未名空间站 (Sat Aug 11 01:31:39 2012, 美东) 刚刚加入Amazon一个星期，跟之前面试我的人好好聊了聊，发现了一个能提高命中率的 诀窍，那就是面试前要好好读读这个东西（Amazon Leadership Principles）： http://www.amazon.com/Values-Careers-Homepage/b?ie=UTF8&node=23 在technical过关的前提条件下，这些看似大空话的东西在评价一个candidate时却是非 常重要的标准。好好揣摩一下，面试时就会发现有些问题是考察candidate是不是符合 这些value的。要是能达到这个境界，彻底了解出题人的意图，那就是手到擒来了。 我所在的组目前就我一个中国人，强烈希望多来些同胞申请。这里是job description ，location在Palo Alto, CA， https://us-amazon.icims.com/jobs/163373/job 有兴趣的可email我：ericapply@yahoo.com

发信人: huaifans (坏粉丝), 信区: JobHunting 标  题: Re: onsite 因为一句话可能要黄了，赳结中, 求建议 发信站: BBS 未名空间站 (Fri Aug 10 11:50:27 2012, 美东) 不够professional , 不够 political 可能不仅仅是因为这句话。在整个面试的过程中，使用的语言和态度比较casual,  老 美很介意这个。 如果面试中提到面更多的人，可以说，Sure I will be very happy to learn more about this position. may I know what their background are?  或者， may I know what type of questions will be asked?  提到面试过的人，＂good talk" 和 ＂very comfortable to talk" 也比较casual.  没有什么不对，就是语气 不对场合。可能换成＂it was very nice meeting xx and xx in your group. Their background are very close to mine and they are both easy going. I like that." 【 在 xpfzzy (Morning) 的大作中提到: 】 : 周二去了一家非常喜欢的公司onsite, 一共面了四个人 (HR, HM, two Seniors). 一切 : 都进行的很好。最后 Hiring Manager 又来了跟我说还有下一轮， 因为有几个人要跟 : 我谈。 可是就在他说这个的过程中， 我突然说 “I have a very good talk with : them and feel very comfortable to talk with them". 等我说完这句话， 他的脸色 : 一下变了， 说要跟那两个谈谈就让我走了。 走的时候我说 "have a good day", 都没 : 理我。结果昨天从猎头那里知道， 他说我能力， 技术都很好， 就是交流不行， 还要

发信人: onlysunny (sunny), 信区: JobHunting 标  题: 很好奇onsite面试每轮的面试题一般是怎么定的？ 发信站: BBS 未名空间站 (Thu Aug  9 14:38:01 2012, 美东) 有经验的面过别人的牛牛来说说，onsite面试每轮的面试题一般是怎么定的？ 比方说boss跟组里的人打招呼，说有人后天来面试，喊了甲乙丙丁四个组员去做考官。 那出的题是甲乙丙丁自己选自己的，还是boss给他们事先分配了不同topic？ 如果是甲乙丙丁自己选自己的题，一般他们会跟boss事先汇报自己出的题不？比方说 难度啊，题型合不合适啊，等等 甲乙丙丁自己互相会讨论自己出的题不？ -- 发信人: mickypiggy (苹果大苹果), 信区: JobHunting 标  题: Re: 很好奇onsite面试每轮的面试题一般是怎么定的？ 发信站: BBS 未名空间站 (Thu Aug  9 17:44:51 2012, 美东) 自己定自己的。题有时会重复或相似。

English is a schizophrenic language that borrows from a lot of other languages, and the rules for making singular nouns into plural nouns are varied and complex. There are rules, and then there are exceptions to those rules, and then there are exceptions to the exceptions. If you grew up in an English−speaking country or learned English in a formal school setting, you're probably familiar with the basic rules: 1. If a word ends in S, X, or Z, add ES. "Bass" becomes "basses", "fax" becomes "faxes", and "waltz" becomes "waltzes". 2. If a word ends in a noisy H, add ES; if it ends in a silent H, just add S. What's a noisy H? One that gets combined with other letters to make a sound that you can hear. So "coach" becomes "coaches" and "rash" becomes "rashes", because you can hear the CH and SH sounds when you say them. But "cheetah" becomes "cheetahs", because th

First, let's look at how you normally import modules. The import module syntax looks in the search path for the named module and imports it by name. You can even import multiple modules at once this way, with a comma−separated list. You did this on the very first line of this chapter's script. Example 16.13. Importing multiple modules at once import sys, os, re, unittest This imports four modules at once: sys (for system functions and access to the command line parameters), os (for operating system functions like directory listings), re (for regular expressions), and unittest (for unit testing). Now let's do the same thing, but with dynamic imports. Example 16.14. Importing modules dynamically >>> >>> >>> >>> >>> >>> >>> >>> sys = __import__('sys') os = __import__('os') re = __import__('re') unittest = __import__('unittest') sys os The built−in __import__ function accom

By now you're probably scratching your head wondering why this is better than using for loops and straight function calls. And that's a perfectly valid question. Mostly, it's a matter of perspective. Using map and filter forces you to center your thinking around your data. In this case, you started with no data at all; the first thing you did was get the directory path of the current script, and got a list of files in that directory. That was the bootstrap, and it gave you real data to work with: a list of filenames. However, you knew you didn't care about all of those files, only the ones that were actually test suites. You had too much data, so you needed to filter it. How did you know which data to keep? You needed a test to decide, so you defined one and passed it to the filter function. In this case you used a regular expression to decide, but the concept would be the same regardless of how you constructed the test. Now you had the filenames of each of the test su

You're already familiar with using list comprehensions to map one list into another. There is another way to accomplish the same thing, using the built−in map function. It works much the same way as the filter function. Example 16.10. Introducing map >>> ... ... >>> >>> [2, >>> [2, >>> >>> ... ... >>> [2, def double(n): return n*2 li = [1, 2, 3, 5, 9, 10, 256, −3] map(double, li) 4, 6, 10, 18, 20, 512, −6] [double(n) for n in li] 4, 6, 10, 18, 20, 512, −6] newlist = [] for n in li: newlist.append(double(n)) newlist 4, 6, 10, 18, 20, 512, −6] [8] map takes a function and a list and returns a new list by calling the function with each element of the list in order. In this case, the function simply multiplies each element by 2. You could accomplish the same thing with a list comprehension. List comprehensions were first introduced in Python 2.0; map has been around forever. You could, if you insist on thinking like a Visu

Python has a built−in filter function which takes two arguments, a function and a list, and returns a list.[7] The function passed as the first argument to filter must itself take one argument, and the list that filter returns will contain all the elements from the list passed to filter for which the function passed to filter returns true. >>> ... ... >>> >>> [1, >>> >>> >>> ... ... ... >>> [1, def odd(n): return n % 2 li = [1, 2, 3, 5, 9, 10, 256, −3] filter(odd, li) 3, 5, 9, −3] [e for e in li if odd(e)] filteredList = [] for n in li: if odd(n): filteredList.append(n) filteredList 3, 5, 9, −3] odd uses the built−in mod function "%" to return True if n is odd and False if n is even. filter takes two arguments, a function (odd) and a list (li). It loops through the list and calls odd with each element. If odd returns a true value (remember, any non−zero value is true in Python), then the element is included in th

>>> import os >>> os.getcwd() /home/you >>> os.path.abspath('') /home/you >>> os.path.abspath('.ssh') /home/you/.ssh >>> os.path.abspath('/home/you/.ssh') /home/you/.ssh >>> os.path.abspath('.ssh/../foo/') /home/you/foo os.getcwd() returns the current working directory. Calling os.path.abspath with an empty string returns the current working directory, same as os.getcwd(). Calling os.path.abspath with a partial pathname constructs a fully qualified pathname out of it, based on the current working directory. Calling os.path.abspath with a full pathname simply returns it. os.path.abspath also normalizes the pathname it returns. Note that this example worked even though I don't actually have a 'foo' directory. os.path.abspath never checks your actual disk; this is all just string manipulation. The pathnames and filenames you pass to os.path.abspath do not need to ex