为什么书呆子不受欢迎 《蝇王》 8.3在一个人产生良知之前，折磨就是一种娱乐。老师很像监狱的狱卒。美丽心灵书呆子已经在思考的东西，正是真实世界看重的东西。他们与别人不一样，不把所有时间用来玩一种耗尽全力但又毫无意义的游戏。学校的真正目的是把儿童都关在同一个地方，一遍大人们白天可以腾出手来把事情做完。问题是：1.不告诉他们这一点；2.把这监狱的大部分交给犯人来管理。文艺复兴时期的学徒是整天劳碌的牧羊犬，而今天的青少年则是神经兮兮、供人玩耍的哈巴狗。他们的疯狂缘于到处都是一片可怕的无聊。校园生活的两大恐怖之处：残忍和无聊。 黑客与画家 编程语言是用来帮助思考程序的，而不是用来表达你已经想好的程序。作者认识的黑客，没有一个喜欢用静态类型语言编程。“众所周知的ECMAScript(JavaScript)便是一个动态语言。除此之外如Ruby、Python等也都属于动态语言，而C、C++等语言则不属于动态语言。”科学界的每一个人，暗地里都相信数学家比自己聪明。黑客应该认识到自己与其他创作者——比如作家和画家——是一类人，不应该是这样。大公司为了避免设计上的灾难，选择了减少设计结果的标准差。但是当你排斥差异的时候，你不仅将失败的可能性排除在外，也将获得高利润的可能性排除在外。赚钱的软件往往不是好玩的软件，其需求量比不上解决客户麻烦问题的软件。微软不鼓励雇员为开源项目做贡献。判断一个人是否具备“换位思考”的能力：看他怎样像没有技术背景的人解释技术问题。《计算机程序的构造和解释》 9.5 程序写出来是给人看的，附带能在机器上运行。 不能说的话 大庭广众之下，你又没有什么观点不愿意说出口？（1.这些话不能说出口；2.它们是正确的）家长和孩子对于脏话相互在对方面前演戏。大多数成年人故意让孩子对世界有一个错误的认识（圣诞老人）。道德禁忌的最大制造者是那些权力斗争中略占上风的一方。这一方有实力推行禁忌，同时又软弱到需要禁忌保护自己的利益。带动流行的两种力量之中，恐惧心比抱负心有力得多。想要做出优秀的作品，你需要一个什么问题都能思考的大脑。尤其是那些似乎不应该思考的问题，你的大脑也要养成思考他们的习惯。搏击俱乐部的第一条规则：不要提到搏击俱乐部。不赞同这个时代的任何一种歇斯底里，但是又不明确告诉别人到底不赞同哪一种歇斯底里。 ## *良好的习惯一个人们拥有言论自由和行动自由的社会，往往最有可能采纳最优方案，而不是采纳最有权势的人提出的方案。专制国家会变成腐败国家，腐败国家会变成贫穷国家，贫穷国家会变成弱小国家。经济学里有一条拉弗曲线：随着税率的上升，税收收入会先增加后减少。随着对公民自由的限制不断上升，政府的力量会先增加后减小。 另一条路 “你的电脑”这个概念正慢慢成为过去时，取而代之的是“你的数据”。用户的胜利：安全，方便代码之城：模块、语言软件发布：一旦能运行，就可以立刻发布软件bug：数量少，处理周期少客户支持：客服人员与黑客在一起全身心投入：构思链逆向的《人月神话》 8.5：人数越来越少，开发效率将指数式增长布鲁克斯假说：程序员一天写出的代码行数是一个常量，与他用的什么语言无关。关注用户：前所未有地了解用户行为金钱问题：没有盗版（是优势，也是问题），易于销售目标客户：安全，外包（公司内部所有不直接感受到竞争压力的部门都应该外包出去，让它们暴露在竞争压力之下）桌面电脑：平台无关创业公司：行动迅速，不太正式，人数少，资金有限。因为你能做到，所以你必须做到（逆向的帕金森定律）。用户的压力变小，程序猿的压力变大为什么不尝试一下？：1.作出用户喜欢的产品；2.保证开支小于收入 如何创造财富 目前还存在的最大的手工艺人群体是程序猿。最顶尖的5%的程序猿写出来全世界99%的优秀软件。任何一个通过自身努力而致富的人，在他们身上因该都能同时发现可测量性和可放大性。可测量性：小团体可放大性：高科技。选择公司要解决什么问题应该以问题的难度为指引，而且此后的各种决策都应该以此为原则。（barriers to entry）创造人们需要的东西，就是创造财富。从经济学观点看什么是创业公司：可以让人更快速工作的地方。 关注贫富分化 反对财富分配不均声音最大的人当中，很多人都少有创造财富的经验。费边社：主张通过渐进温和的改良主义方式来走向社会主义，而非透过马克思主义所主张的阶级革命，并强调通过教育的途径让权力回到知识精英的手中。奥卡姆剃刀：他在《箴言书注》2卷15题说“切勿浪费较多东西，去做‘用较少的东西，同样可以做好的事情’。”积累财富最常见的方法其实是偷窃。游牧社会是偷别人的牲口，农业社会是征税（和平时期）和直接掠夺（战争时期）。技术会引起收入差距的扩大，但是会缩小物质或社会地位等其它差距。但是教育的漏洞任然存在。现代社会的收入差距扩大是一种健康的信号。
《黑客与画家》阅读笔记
看见
柴静的《看见》是本好书，我为最初凭感觉将其归为开复哥心灵鸡汤式的自传“小说”而抱歉，看来事情还是要亲眼看见了才能下结论。 CCTV是个恶心的玩意儿，我也好多年没正眼看过电视了，但就作为洗脑工具和控制社会舆论而言，可谓比媳妇儿还忠贞，结果是，《看见》一书讲述的案例，除了卢安克，我居然都很清楚，尽管柴静的节目对于整个CCTV体系而言是很边缘化的，但是这本书一看 ，很容易给大家造成柴静就是整个CCTV的错觉。 在体制内生存，不能触碰的底线比一般行业高得离谱，柴静能在“制度与人文的十字路口”飚车不出车祸，实属不易。对此，柴静自己在书里也很隐晦地表达了这只能意会不可言传的苦闷：“每一条细微的新闻背后，都隐藏一条冗长的逻辑链，在我们这，这些逻辑链绝大多数是同一朝向，正式因为这不能言说又不言而喻的秘密，我们需要提醒自己，绝不能走到这条逻辑链的半山腰就嚎啕大哭。”这朝向是什么，相信读到书上这段话时，脑袋清醒点的读者都能对这份大家共同的苦闷充分理解了，真是聪明。 尽管说是从业十年的自传，但实在是比一般传记精彩高明太多了。通常的自传，自我中心意识浓烈，柴静则在叙事和自我的微妙变化间掌握得很好，在新闻事例的庞大和震撼之前，自我已经显得很渺小了，柴静还一直在书中再三试图弱化自我，其实你看，十年过去了，柴静几乎还是那个柴静，无非经历的事情多了些，变化不大嘛，但回味开来，又觉得十年的自我论证真是酣畅淋漓，高明。 上个月看了十来本书，《看见》肯定不是最好的，却应该是唯一适合推荐的。矛盾的是，你得看过那些“最好的书”，才能充分理解《看见》在体制的厚重挤压下发芽生根的不容易，大部分的人看着这本书，估计也就是感动感动还是感动，然后呢？没有了。
油猴脚本第二炮：googleSearchCountRobot，看看苦逼的程序猿，每天要Google多少次
先声明，纯属无聊念头，粗制滥造，感慨于每天一半时间都在Google上度过，写个小程序看看每天Google多少次。。 注：由于不是用 chrome 扩展的办法做的，似乎没办法把 .com .hk .cn 神马的数据整合到一起，反正用 Google 肯定也只用一个吧。 另注：开了 Google Instant predictions（Google 即搜即得联想功能） 的，俺还没研究怎么监测。。。 总之就是个闲来无事的小玩意儿，如果你认为有什么好玩的值得实现，欢迎留言。。。 使用方法参见 四川理工学院教务系统自动登录器 suseAutoLoginRobot。 点击下载：/labor/googleSearchCountRobot.user.js 或者到 http://userscripts.org/scripts/show/163880 安装。 截图一张，数据就在左下角了。 另外构想了一个复杂一点的把戏，清明后再研究吧。菇凉等着俺来了~~
VS2012下配置opencv+directshow(CCameraDS)，支持多摄像头
最近学习 OpenCV，研究智能监控神马的。简单实现了运动跟踪后，开始着手自己的摄像头类及多摄像头的研究（实际项目环境可能是8个甚至16个摄像头）。 前期 VS2012 + OpenCV 的配置方法，可以参考 Win7下OpenCV2.4.3结合VS2012的配置 等文章，网上资料较多，本文就不详述了。 问题主要发生在调用多摄像头上，搜索一番，发现只在 OpenCV 中文网站 存在一个使用 DirectShow 实现多摄像头支持的 CCameraDS 类。下载并添加到项目里后，发现压缩包里并没有其所说的“集成了DirectShow，勿需安装庞大的DirectX/Platform SDK”。真糟糕，只能自己找了，又是一番搜索，发现 DirectShow 这玩意儿似乎已经开始被微软给淘汰了，最后存在是在多年前的 DirectX 9.0b 包里，可以在这里下载到：DirectX9.0b SDK下载地址及安装说明。 在下载过程中，我发现 VS2012旗舰版是自带了 SDK 的，在 C:\Program Files (x86)\Microsoft SDKs\Windows\v7.1A\Include。 如果你也有这玩意儿，那就可以直接在项目属性里 Additional Include Directories 添加 $(FrameworkSDKDir)Include，Additional Library Directories 添加 $(FrameworkSDKDir)Lib。 完成之后，会发现任然无法 #include “qedit.h”，感情新的 SDK 里已经没了这头文件，也就相当于没了 DirectShow，加上便是，一番寻找后搞定，解决了一点小问题后（qedit.h 里还需包含一个头文件），我把它上传到了博客：点击下载。 OK，现在，就能像 CCameraDS 类 的例程一样使用这个类了。
四川理工学院教务系统自动登录器 suseAutoLoginRobot
由于教务系统启用了验证码，小叶不想去搞验证码识别，所以登录器寿终正寝了，在 tampermonkey 里把 suseAutoLoginRobot 删除就行了。 去年六月做了 四川理工学院教务系统无弹窗登录器 ，人气不错，每到选课都能达到数万的 PV 和数百 IP ，该版本虽然加快了尝试登录的速度，但是实际上并没有本质上的变化，还是得自己动手，运气不好手抽筋。 一直有想法实现自动爆破，寒假简单看了看 chrome 浏览器扩展的制作方法，并且作了些尝试，后来想到兼容火狐甚至一些国产浏览器，于是干脆做成了油猴脚本。也就是现在这玩意儿。 注意：自动爆破功能只在选课那两天能看到效果。意见、建议、BUG反馈欢迎给我留言。 进入登录器：http://www.yekezhong.com/labor/login.html 由于这玩意儿上他的前身复杂不少，要正确使用，且听俺细细道来。 首先，要实现登录错误跳转回来再自动登录的循环，光靠登录器页面自身肯定不可能完成了，毕竟到错误页面后已经是另外一个网站。 于是，为了实现功能，咱们必须找一个更强大的家伙来帮忙，它就是传说中的油猴脚本（Greasemonkey）： Greasemonkey 原本是Google一名员工开发的火狐插件，可以让用户根据自己的需要去修改他所看到的网站的样式，而所有的修改都由一个 Javascript 代码脚本（油猴脚本）控制，可以实现一些譬如把某个按钮隐藏了，把某一个区块的字体颜色改了等等，只要程序员发挥他的想象力，那么油猴脚本的能力和作用可以说是无穷无尽的。chrome , firefox , ie 浏览器都支持油猴脚本，差别是各自的支持方法不同。俺这里只介绍 chrome 下的使用方法。 Step 1 : 当然需要安装 Google Chrome 浏览器：官方下载地址，或者在360软件管家搜索 chrome 下载。 Step 2 : 尽管 chrome 原生支持油猴脚本，但是推荐安装油猴脚本管理扩展 Tampermonkey，方便管理和自动升级。安装好 chrome 后，进入 chrome web store 安装。安装完成后，在 chrome 右上角可以看到 Tampermonkey 的图标。【关于 chrome 的扩展，可以参考我之前的文章：谷歌Chrome浏览器自用插件推荐】 Step 3 : 我已经将 suseAutoLoginRobot 的脚本程序上传到了博客。点击安装，Tampermonkey会自动监测到脚本，确认安装即可。另外，我也将脚本上传到了全球最大的油猴脚本基地 http://userscripts.org/scripts/show/161100，也可以在这里安装，你还可以在这个网站找到很多实用的玩意儿。当然，你还可以在GitHub找到我https://github.com/yekz/suseAutoLoginRobot/。 Step 4: 以上三步，suseAutoLoginRobot 装配工作已经完成。刷新登录器页面，这时候，只需要填写学号和密码并保存，选择爆破时长，点击开始自动爆破即可。
Item 25: Consider support for a non-throwing swap.
This article is one of <Effective C++> reading notes. Part 4: Designs and Declarations Item 25: Consider support for a non-throwing swap. Things To Remember (step 1) Provide a swap member function when std::swap would be inefficient for your type, Make sure your swap doesn’t throw exceptions. (step 2) If you offer a member swap, also offer a non-member swap that calls the member,for classes (not templates), specialize std::swap, too. (step 3) When calling swap, employ a using declaration for std::swap, then call swap without namespace qualification. It’s fine to totally specialize std templates for user-defined types, but never try to add something completely new to std. Key Words total template specialization (全特化) and partially template specialization(偏特化): This is a total template specialization and you do not need to disambiguate any symbols, so no need for typename. 12345678// total template specializationnamespace std {truetemplate<>truevoid swap<Widget>(Widget& a, Widget& b)true{truetrueswap(a.pimpl, b.pimpl);true}} partially template specialization only works for classes, not functions! You can only totally specialize function templates - anything else is function overloading in the std namespace(which the C++ standard disallows). 12345678910// partially template specializationnamespace std{ /* Do **not** do this in the std namespace!!! You're not actually partially specializing the function, you're overloading the function in the std namespace which is prohibited by the C++ standard. */ template<typename T> void swap<Widget<T> >(Widget<T>& a, Widget<T>& b) {}} Failure transparency(故障透明): In a distributed system, failure transparency refers to the extent to which errors and subsequent recoveries of hosts and sevices within the system are invisible to users and applications. Failure transparency is one of the most difficult types of transparency to achieve since it is ofte
Item 24: Declare non-member functions when type...
This article is one of <Effective C++> reading notes. Part 4: Designs and Declarations Item 24: Declare non-member function when type conversions should apply to all parameters. Things To Remember If you need type conversions on all parameters to a function (include the one pointed to by this pointer), the function must be a non-member. Key Points The opposite of a member function is a non-member function, not a friend function. Wherever you can avoid friend functions, you should, because, much as in real life, friends are often more trouble than they’re worth. 在设计 C++ 程序时，第一考虑的应该是怎样用最少的 C++ 知识来达成目地。重载操作法，对于不使用 template 的场合，多半不是必要的。所以，更偏向于先实现一个 const Rational MulRational(const Rational& lhs, const Rational& rhs) 的函数，再根据需要实现 operator* 调用它。 Code 1234567891011121314151617181920212223242526272829303132333435#include "stdafx.h"class Rational {public:true// ctor is deliberately not explicit;true// allows implicit int-to-Rational conversionstrueRational(int numerator = 0, int denominator = 1);true// accessors for numerator and denominator - see Item 22trueint numerator() const;trueint denominator() const;true// for why this function declared the way it is,true// think of this: if (a * b = c) [Item 3]true/* const Rational operator*(const Rational& rhs) const; */private:true// ...};const Rational operator*(const Rational& lhs, const Rational& rhs){truereturn Rational(lhs.numerator() * rhs.numerator(),truetruetruetruetruelhs.denominator() * rhs.denominator());}int main(){trueRational oneEight(1, 8);trueRational oneHarf(1, 2);trueRational result;trueresult = oneHarf * 2; // finetrue/* result = 2 * oneHarf; // with member operator*, error! */trueresult = 2 * oneHarf;truereturn 0;}
Item 23: Prefer non-member non-friend functions to member...
This article is one of <Effective C++> reading notes. Part 4: Designs and Declarations Item 23: Prefer non-member non-friend functions to member functions. Things To Remember Prefer non-member non-friend function. Doing so increases encapsulation, packaging flexibility, and functional extensibility. Key Points Increases encapsulation: It affords us the flexibility to change things tin a way that affects only a limited member of clients. The less code that can see the data (i.e., access it), the more the data is encapsulated. Non-member non-friend function doesn’t increase the number of functions than can access the private parts of the class. Module interfaces should be streamlined as much as possible. Two things are worth noting: 1.) this reasoning applies only to non-member non-friend functions. 2.) a function be a non-member of one class doesn’t mean it can’t be a member of another class. A more natural approach would be to make clearBrowser a nonmember function in the same namespace as WebBrowser.Increases packaging flexibility (包装弹性): This is exactly how the standard C++ library is organized. Rather than having a single monolithic <C++StandardLibrary> header containing everything in the std namespace, there are dozens of headers (e.g., <vector>, <algorithm>, <member>, etc.), each declaring some of the functionality in std.Increases functional extensibility (功能扩展性): Putting all convenience functions in multiple header files — but one namespace — also means that clients can easily extend the set of convenience functions. All they have to do is add more non-member non-friend functions to the namespace. Clients can drive new classes to extend the old one, but derived classes have no access to encapsulated (i.e., private) members in the base class. Code 12345678910111213141516171819202122232425262728293031// header "webbrowser.h" -- header for class WebBrowser itself // as well as "core" WebBrowser-releated functionality namesp
Item 22: Declare data members private.
This article is one of <Effective C++> reading notes. Part 4: Designs and Declarations Item 22: Declare data members private. Things To Remember Declare data members private. It gives clients syntactically uniform access to data, affords fine-grained access control, allows invariants to be enforced, and offers class authors implementation flexibility. protected is no more encapsulated than public. Key Words syntactic consistency (语法一致性): Ways to facilitate the correct use include consistency in interfaces and behavioral compatibility with build-in types. [Item 18] fine-grained access control: Coarse-grained vs. fine-grained access control. class invariants: A class invariant is an invariant used to constrain objects of a class. Methods of the class should preserve the invariant. The class invariant constrains the state stored in the object. Key Points Suppose we have a protected data member, and we eliminate it, then all the derived classes that use it might be broken now. Unencapsulated means unchangeable, especially for classes that are widely used. So from an encapsulation point of view, there are really only two access levels: private (which offers encapsulation) and everything else (which doesn’t). [see alse <The Design and Evolution of C++>] 比 private 更彻底的方案是把私有部分全部放在一个私有的内部类中，并把私有类的定义从公开的头文件里删掉，只被实现所见。[Item 31] Code 12345678910111213// Fine-grained access control class AccessLevels { public: trueint getReadOnly() const { return readOnly; } void setWriteOnly(int value) { writeOnly = value; } void setReadWrite(int value) { readWrite = value; } int getReadWrite() const { return readWrite; } private: trueint noAccess; // no access to this int int readOnly; true// read-only access to this int trueint writeOnly; // write-only access to this int trueint readWrite; // read-write access to this int };
Item 21: Don’t try to return a reference when you must return...
This article is one of <Effective C++> reading notes. Part 4: Designs and Declarations Item 21: Don’t try to return a reference when you must return an object. Things to remember Never return a pointer or reference to a local stack object, a reference to a heap-allocated object, or a pointer or reference to a local static object if there is a chance that more than one such object will be needed. Key words Stack and Heap(Isn’t std::stack or heap(data structure) “heap(data structure)”)): A function can create a new object in only two ways: on the stack or on the heap. Value types are created on the stack, and reference types are created on the heap. About stack, system will allocate memory to the instance of object automatically, and to the heap, you must allocate memory to the instance of object with new or malloc manually. When function ends, system will automatically free the memory area of the stack, but to the heap, you must free the memory area manually with free or delete, else it will result in the memory leak. Code analysis Bad code 1: 12345678/************************************************************************* warning! bad code!************************************************************************/inline const Rational& operator*(const Rational& lhs, const Rational& rhs) {trueRational result(lhs.n * rhs.n, lhs.d * rhs.d); return result;} A more serious problem is that this function returns a reference to result, but result is a local object, and local objects are destroyed when the function exits. This version of operator*, then, doesn’t return a reference to a Rational — it returns a reference to a former and empty Rational. Bad code 2: 12345inline const Rational& operator*(const Rational& lhs, const Rational& rhs){trueRational *result = new Rational(lhs.n * rhs.n, lhs.d * rhs.d); return *result;} Will, who will apply delete to the object conjured up by your use of new？ Bad code 3: 123456inline const Rational& operator*(const Rationa