Datasets:

VoiceOfML
/

MLMRL-Library

License:

vomebook commited on Jun 8

Commit

e8c15f5

verified ·

1 Parent(s): cfdd073

Delete 安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”

Browse files

This view is limited to 50 files because it contains too many changes. See raw diff

Files changed (50) hide show

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/.sync/FolderType +0 -1
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/.sync/ID +0 -1
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/.sync/IgnoreList +0 -54
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/.sync/StreamsList +0 -8
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/.sync/root_acl_entry +0 -0
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/__所有电子书的清单__.html +0 -0
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/__所有电子书目录的密钥__.txt +0 -29
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/0.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/1.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/2.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/3.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/4.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/choose-it-book.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/cxx-coding-standards-101-rules.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/cxx-cross-platform-develop-0-overview.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/cxx-cross-platform-develop-1-compiler.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/cxx-cross-platform-develop-2-language.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/cxx-cross-platform-develop-3-exception.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/cxx-cross-platform-develop-4-hardware.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/defect-of-java-beginner-0-overview.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/defect-of-java-beginner-1-algorithm.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/defect-of-java-beginner-2-oo.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/job-in-economy-decline.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/test.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/twitter-and-break-news-and-people.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/5.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/6.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/7.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/80-20-principle-0-overview.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/80-20-principle-1-software-developing.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/cxx-cross-platform-develop-5-os.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/cxx-object-destroy-overview.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/cxx-object-destroy-with-io-stream.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/cxx-object-destroy-with-process.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/daily-build-0-overview.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/daily-build-1-advantage.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/daily-build-2-prepare.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/daily-build-3-proces.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/defect-of-java-beginner-3-code-style.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/defect-of-java-beginner-4-exception.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/from-surface-to-essence.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/google-search-fatal-bug.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/how-to-choose-opensource-project.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/multi-process-vs-multi-thread.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/ria-review-flash-silverlight-javafx.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/study-technology-in-three-steps.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/03/80-20-principle-2-management-overview.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/03/80-20-principle-3-management-hire.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/03/80-20-principle-4-management-encourage.html +0 -26
安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/03/book-review-mythical-man-month.html +0 -26

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/.sync/FolderType DELETED Viewed

	@@ -1 +0,0 @@
1	- d8:brandingi0e31:disable_remove_from_all_devicesi0e4:modei0e5:owner5:linji4:typei1ee

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/.sync/ID DELETED Viewed

	@@ -1 +0,0 @@
1	- ��i��n^⋧�e��??�슃ԅ

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/.sync/IgnoreList DELETED Viewed

@@ -1,54 +0,0 @@
-# IgnoreList is a UTF-8 encoded .txt file that helps you specify single files, paths and rules
-# for ignoring during the synchronization job. It supports "?" and "*" wildcard symbols.
-#
-#
-# OS generated files #
-$RECYCLE.BIN
-$Recycle.Bin
-System Volume Information
-ehthumbs.db
-desktop.ini
-Thumbs.db
-lost+found
-.DocumentRevisions-V100
-.TemporaryItems
-.fseventsd
-.icloud
-.iCloud
-.DS_Store
-.DS_Store?
-.Spotlight-V100
-.Trashes
-.Trash-*
-.trashed-*
-~*
-*~
-.~lock.*
-*.part
-*.filepart
-.csync_journal.db
-.csync_journal.db.tmp
-*.swn
-*.swp
-*.swo
-*.crdownload
-.@__thumb
-.thumbnails
-._*
-*.tmp
-*.tmp.chck
-.dropbox
-.dropbox.attr
-.dropbox.cache
-.streams
-.caches
-.Statuses
-.teamdrive
-.SynologyWorkingDirectory
-@eaDir
-@SynoResource
-#SynoRecycle
-#snapshot
-#recycle
-.!@#$recycle
-DfsrPrivate

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/.sync/StreamsList DELETED Viewed

@@ -1,8 +0,0 @@
-# StreamsList is a UTF-8 encoded .txt file that helps you specify alternate streams,
-# xattrs and resource forks white list. It supports "?" and "*" wildcard symbols.
-#
-#
-#
-com.apple.metadata:_kMDItemUserTags
-com.apple.ResourceFork
-com.apple.metadata:kMDItemFinderComment

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/.sync/root_acl_entry DELETED Viewed

File without changes

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/__所有电子书的清单__.html DELETED Viewed

The diff for this file is too large to render. See raw diff

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/__所有电子书目录的密钥__.txt DELETED Viewed

@@ -1,29 +0,0 @@
-以下是【编程随想电子图书馆】所有目录的 BT Sync 密钥。
-通过这几个密钥，你可以用 BT Sync 自动同步到每一个目录包含的【所有】电子书。
-俺会时常更新。每次更新后，BT Sync 会自动把【新增的】电子书同步到你的硬盘。
-BRSSYZTSAC6UGYTUOJ22L4GCO7QESPPBD    政治
-BNZ6DOA6W577O6GUNH7C3MY6DWC6FTDQB    心理学
-BSH7FXJFVWJTKWGSX5GTWX7PHZZ2D2M7Q    历史
-B2FRYA6AXCDW6CF4YJVFWKH2HAXOFICOX    经济
-B3WNBTAAFFAODFR6FQ3E3L5BBSJAFNBSJ    管理
-BZR4TTYHT25QWUIE6YNMAKWUGBHKSGLC6    社会学
-BMBB5YLBIJJAE5H6TP27OS7YCEUKCYHZK    文艺
-B6WWVBXPMZDI5IL4KED6AAHA5FO4UNKQF    哲学
-BKKORLE67ZDUHGHVWAVSRK3N5I7BXLCED    科普
-BMWWZALG4P56LREF47EE2WSWHZEM4E6BL    军事
-BUPSDXFA3TP7KCMLHALRHLIX2FEJEUJFE    IT
-关于 BT Sync 的扫盲教程，参见以下链接
-https://program-think.blogspot.com/2015/01/BitTorrent-Sync.html
-以下页面是【所有电子书】的清单。
-清单中包含每本书的“中文名、英文名、作者、添加日期、简介”。
-https://github.com/programthink/books
-除了上面“电子图书馆”那几个目录，下面这2个目录，你可能也会感兴趣。
-BTLZ4A4UD3PEWKPLLWEOKH3W7OQJKFPLG    翻墙软件（包含常见的翻墙软件，时常更新）
-B7P64IMWOCXWEYOXIMBX6HN5MHEULFS4V    “博客离线浏览”以及“博客电子书制作脚本”

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/0.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>如何成为优秀开发人员[0]：怎样算是优秀的？ - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">如何成为优秀开发人员[0]：怎样算是优秀的？</a></h1>
-<div class="post-info"><span class="date-header">2009-01-17</span><a href="../../tags/E8818CE59CBAE782B9E6BBB4.html" class="tag">职场点滴</a> </div>
-<hr/>
-<div class="post">
-<h2>★引子</h2><br />&#12288;&#12288;有感于国内软件开发人员的素质普遍低下，招聘程序员往往面试了N个人都看不到一个顺眼的（当然这里面有很大原因是教育体制的问题）。因此考虑写一个系列，聊一下“如何成为优秀的开发人员”这个话题。<br /><a name='more'></a><!--program-think--><br /><br /><h2>★何为优秀？</h2><br />&#12288;&#12288;要想成为一个优秀的开发人员，先得搞清楚什么样的开发人员才能称得上是优秀的？要给“优秀开发人员”下一个准确的定义有一点点困难，于是我用举例来说明。<br />&#12288;&#12288;经我多年观察，对于大部分的软件开发团队都有这样的一个现象，那就是团队中的<b>少数</b>（一般来说，小于总人数的20%）开发人员具有更快的开发效率、更好的程序设计、更好的代码质量、更善于 debug、更能够解决技术难题......（总之就是让 team leader 事事省心）。而且这一小撮开发人员的贡献总和可能与另外那一大撮人（大于总人数的80%）的贡献总和不相上下（甚至可能超过）。那么，这一小撮开发人员，就是我所谓的优秀开发人员。（跑题一下，实际上这就是二八原理的一种生动体现，请看<a href="../../2009/02/80-20-principle-0-overview.html">二八原理系列的帖子</a>）<br />&#12288;&#12288;说到这里，列位看官应该明白我所指的“优秀开发人员”是什么样的了吧？（如果个别读者还是不明白，那只能说明你智商偏低，本系列帖子不适合你）<br />&#12288;&#12288;如果你觉得自己目前还不属于这一小撮之列，但是希望自己日后成为他们中的一员，你该怎么做呢？我的建议就是：仔细阅读后续的“如何成为优秀的开发人员”系列文章。我会在里面逐一介绍相关的东东，或许有助于你能力的成长。<br />&#12288;&#12288;反之，如果你自认为已经<b>完全</b>符合我所说的优秀开发人员，那么恭喜你，你可以直接略过该系列文章，去看点别的什么东西吧 :-)<br />&#12288;&#12288;本系列不会涉及到具体的编程语言技巧、不会涉及到具体的开发工具、不会涉及到具体的软件框架、不会涉及到任何当下时髦的概念（比如什么 OOP、FP、Pattern、SOA、REST、RIA......）。至于我具体会聊些啥，大伙看了以后就知道了。<br />&#12288;&#12288;最后补充声明一下：这里所说的优秀开发人员和开发大牛（洋文叫做 Guru）不是一回事，看完这个系列文章或许有助于你成为优秀开发人员，但并不能帮助你成为开发大牛。<br /><br /><br /><h2>★本系列的目录</h2><br /><a name="index"> </a><br />为了方便阅读，把本系列帖子的目录整理如下：<br /><a href="../../2009/01/1.html">1. 关于兴趣</a><br /><a href="../../2009/01/2.html">2. 关于自学能力</a><br /><a href="../../2009/01/3.html">3. 设定个人发展目标</a><br /><a href="../../2009/01/4.html">4. 做正确的事</a><br /><a href="../../2009/02/5.html">5. 正确地做事（概述）</a><br /><a href="../../2009/02/6.html">6. 正确地做事（善用工具）</a><br /><a href="../../2009/02/7.html">7. 正确地做事（善用自动化）</a><br />8. （未完待续）<br /><br /><br /><b>俺博客上，和本文相关的帖子（需翻墙）</b>：<br />《<a href="../../2019/12/Time-and-Life.html">时间与人生——跨入本世纪20年代的随想</a>》<br />《<a href="../../2018/06/weekly-share-121.html">德鲁克谈【自我管理】——＜哈佛商业评论＞史上最受欢迎的文章</a>》<br />《<a href="../../2015/06/The-Mythical-Theories-of-Success.html">成功学批判——简述其危害性及各种谬误</a>》<br />《<a href="../../2009/02/80-20-principle-0-overview.html">无处不在的二八原理</a>》（系列）<br />《<a href="../../2009/09/how-to-personal-branding.html">如何包装个人品牌？</a>》<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完���，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/01/0.html">https://program-think.blogspot.com/2009/01/0.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/1.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>如何成为优秀开发人员[1]：关于兴趣 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">如何成为优秀开发人员[1]：关于兴趣</a></h1>
-<div class="post-info"><span class="date-header">2009-01-18</span><a href="../../tags/E5BF83E79086E5ADA6.html" class="tag">心理学</a> <a href="../../tags/E8818CE59CBAE782B9E6BBB4.html" class="tag">职场点滴</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;<a href="../../2009/01/0.html">上一篇帖子</a>已经给出了“优秀开发人员”的定义，那么现在我来说说成为优秀开发人员的头一个重要因素：<b>兴趣</b>。<br />&#12288;&#12288;因为物理学超级大牛爱因斯坦曾说过：兴趣是最好的老师。俺对此深以为然。所以咱们先从兴趣这个话题聊起。<a name='more'></a><!--program-think--><br />&#12288;&#12288;兴趣这玩意是心理学层面的东西，据说人在本能上有一种“构建”的快感（例如小朋友喜欢搭积木就是）。有些人天生喜欢写程序，就是因为能够从中体会到构建的快感。鉴于心理学不是本博客重点关注的话题，暂不再深入聊下去。<br />&#12288;&#12288;（本文写完6年之后，俺又另外写了一篇《<a href="../../2015/12/Hobbies-and-Interests.html">什么是【真正的】兴趣爱好？以及它有啥好处？</a>》，供大伙儿参考）<br /><br />&#12288;&#12288;有兴趣的开发人员和没兴趣的开发人员，差别怎么就这么大捏？这主要是因为有兴趣的人，比较有动力去学习新东西、碰到新鲜玩意喜欢去刨根问底、碰到有开发过程的困难（比如一些难调试的bug）也显得比较有耐心、......久而久之，两种人的差别就渐渐地体现出来鸟。<br />&#12288;&#12288;所以，如果你属于下列情况之一：<br />&#12288;&#12288;&#12288;&#12288;1、即将进入学校学习软件这门专业<br />&#12288;&#12288;&#12288;&#12288;2、已经从学校毕业，即将入这个行当的新手菜鸟<br />&#12288;&#12288;&#12288;&#12288;3、已经工作了若干年，但还不属于优秀开发人员<br />&#12288;&#12288;&#12288;&#12288;4、已经在其它行当工作了若干年，觉得软件这行不错，想转行过来<br />&#12288;&#12288;并且企图在将来成为一个如我所说的优秀开发人员，那么你首先要判断一下，自己是否<b>确实喜欢</b>软件开发。<br /><br />&#12288;&#12288;用如下简单的问题就能够判断出你是否<b>确实喜欢</b>软件开发：<br /><blockquote style="background-color:#DDD;">假设有两个工作岗位A和B供你选择。<br />工作岗位A：你可以随意地去干<b>除了软件开发之外</b>的任何事情（只要你喜欢的，都可以）；<br />工作岗位B：你必须全职从事软件开发，不能干其它事情。<br />并且岗位A的收入比岗位B高很多。</blockquote>&#12288;&#12288;对上面这个问题，你会选择哪个工作岗位？如果你毫不犹豫（其实稍微犹豫一下也没太大关系）地选择B，那么恭喜你，你<b>确实</b>对软件开发<b>非常</b>热衷。我建议你把“如何成为优秀的开发人员”这个系列的帖子都看完，对你会有帮助。<br /><br />&#12288;&#12288;看到这里，可能有读者要问了：如果我原先对软件开发兴趣不大，有什么方法能让我变得对软件开发非常热衷？<br />&#12288;&#12288;想回答这个问题，大伙先要明白这样一个事情：根据心理学（不好意思，又扯上心理学了）的研究，大部分人的性格、兴趣、气质等因素，大都形成于<b>20岁左右</b>之前。在<b>20岁左右之后</b>，一般不会有太大的改变。<br />&#12288;&#12288;所以，你如果已经从学校毕业，又工作了若干年，那么你的兴趣多半已经定型，改变的机会和效果不大（但也不是绝对不可能改变）。兴趣这种东西是自然形成的。依靠主观愿望去改变自己或者别人的兴趣，最终的效果并不理想。与其这样，不如找一个自己真正感兴趣的行业去做。<br />&#12288;&#12288;反之，如果你年龄尚小（不到20岁），还在读中学（甚至小学），那你现在还不必考虑“如何成为优秀开发人员”这个问题。在这个年龄段，重要的是发现自己的兴趣点在哪里，并让它充分发挥出来。<br /><br />&#12288;&#12288;关于兴趣的话题就聊到这里，下一个话题咱们来聊聊“<a href="../../2009/01/2.html">自学能力</a>”。<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>��权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/01/1.html">https://program-think.blogspot.com/2009/01/1.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/2.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>如何成为优秀开发人员[2]：关于自学能力 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">如何成为优秀开发人员[2]：关于自学能力</a></h1>
-<div class="post-info"><span class="date-header">2009-01-19</span><a href="../../tags/E8818CE59CBAE782B9E6BBB4.html" class="tag">职场点滴</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;通过本系列<a href="../../2009/01/1.html">上一篇帖子</a>，你应该已经搞清楚自己是否【确实】有兴趣从事软件开发工作。现在我们来聊一下开发人员的自学能力（终于开始介绍实质性的东东了）。<a name='more'></a><!--program-think--><br /><br /><a name="importance"> </a><br /><h2>★自学的重要性</h2><br />&#12288;&#12288;为啥我把“自学能力”排到“兴趣”之后捏？因为大伙儿都明白，IT这行知识的更新速度巨快。有很多新玩意儿在你读书的时候还没有发明出来呢？退一步讲，即使某个新技术在你上学的时候已经发明出来，你的计算机老师也未必会教你（或许他/她自己也不懂）。再退一步讲，即使你上学时的计算机老师比较牛，会把当时新出来的某个技术教给你，但是你将来工作中需要用到的新技术未必就当年老师教给你那个......<br />&#12288;&#12288;上面啰嗦了一大堆，无非想说，你工作中终归会需要用到某个新技术是你以前没学过的。所以，自学能力是非常重要滴。以此相对照的是：国内的大多数开发人员都比较缺乏自学能力（这个也跟国内的教育体制有关）。所以，对于立志成为优秀开发人员你，需要先搞定自学能力这个东东。<br /><br /><a name="active"> </a><br /><h2>★自学的主动性</h2><br />&#12288;&#12288;我把国内的开发人员按照自学的主动性不同，分为如下几类（你顺便想想自己属于哪一类）：<br /><br /><h3>◇抗拒自学者</h3><br />&#12288;&#12288;这类人不愿意自学（部分人是由于懒惰、另一些是由于抵触新事物）。当工作中要用到某项新技术而需要自学时，他/她就找若干理由推诿。我估计这类人占的比例不多，万一你正好属于这种人，那还是趁早改行，别在这个行业浪费青春了（因此也别再继续看这个帖子了）。<br /><br /><h3>◇被动自学者</h3><br />&#12288;&#12288;这类人平时没事不会想到去自学新东西。只有当上司逼着他去学某某技术，他才勉为其难地去学。我建议这类人也不用继续看这个系列的帖子了，找个凉快的地方呆着去吧。<br /><br /><h3>◇需求驱动型自学者</h3><br />&#12288;&#12288;这类人自学的动机和方向是基于需求驱动。比如因为工作中要用到 XX框架、XX库、XX软件，然后就利用业余时间找资料去看。如果你属于这类人，就得考虑考虑向第4类人转型。<br /><br /><h3>◇计划型自学者</h3><br />&#12288;&#12288;这类人自学的动机和方向是基于自己的规划。【定期】看看自己的知识结构有什么缺陷、将来自己想朝什么方向发展、最近哪个新东西将来会用得上 ......然后给自己定一个学习计划。<br />&#12288;&#12288;如果你属于这类人，恭喜你。<br /><br /><a name="method"> </a><br /><h2>★自学的常用招数</h2><br />&#12288;&#12288;现在，咱们来聊聊和自学有关的几个【常用】招数。<br /><br /><h3>◇搜索引擎</h3><br />&#12288;&#12288;由于使用搜索引擎是互联网时代的<b>必备</b>基本功，搜索引擎的重要性我就不多废话了（千万别跟我说你还不懂得用搜索引擎啊）。<br /><br /><h3>◇百科类网站</h3><br />&#12288;&#12288;此处所说的“百科类”例如：<a href="https://zh.wikipedia.org/" target="_blank" rel="nofollow">中文维基百科</a>、<a href="http://baike.baidu.com/" target="_blank" rel="nofollow">百度百科</a> ...<br />&#12288;&#12288;百科类网站，顾名思义，就是拿来当百科全书使的。当你听说某个时髦的新术语，但又不甚了解，这时候就可以用上百科类网站了。各种专业术语一般都可以在百科类网站上查到比较具体的解释。不过百科类网站的功能也就仅限于此，当你需要深入了解某个技术时，它是远远不够的。<br /><br /><h3>◇订阅“BBS、Mailing List、Blog”</h3><br />&#12288;&#12288;这3种东东的特点是具有一定的交互性，而且大都支持软件订阅。通过订阅一些专业的、针对某个领域的“BBS、Mailing List、Blog”，你��以了解该领域的实时动态、了解该领域的热点话题、了解该领域的发展方向。你自己如果碰到疑难杂症，还可以在上面找人问（运气好的话还能交几个朋友）。<br />&#12288;&#12288;为啥我特地强调【订阅】捏？因为使用订阅可以让信息自动跑到你面前，省去了打开浏览器挨个访问网站的麻烦（因此也节省了时间）。这3种东东的局限性是：难以通过它们【系统性】地掌握某个比较复杂的技术（比如你要学习某个有一定复杂度的编程语言）。<br /><br /><h3>◇看书（包括电子书和纸版书）</h3><br />&#12288;&#12288;当你要系统性地掌握某个比较复杂的技术时，首选方法是：找一本针对性的<b>好书</b>。由于每一个具体的领域，都有N本书可供选择，这时候如何取舍就非常重要。如果你选的书比较差，不但看起来吃力，甚至会把你带到沟里。这时候你就得利用搜索引擎或者专门的网站（例如<a href="http://www.douban.com/" target="_blank" rel="nofollow">豆瓣</a>、<a href="http://www.amazon.com/" target="_blank" rel="nofollow">亚马逊</a>）来识别好书与坏书。关于如何鉴别一本书的好坏，我在帖子《<a href="../../2009/01/choose-it-book.html">如何选择 IT 技术书籍</a>》里有深入讨论，这里就不再啰嗦了。<br />&#12288;&#12288;再来说说电子书和纸版书。首先电子书的资源非常多，大部分国外出版的IT书都可以在Internet上找到免费的电子版。另外还有电子书还有如下好处：便于携带、能全文搜索、能共享、能备份、还省钱。从目前的发展趋势看，电子书占据主流地位只是一个时间问题。基于上述理由，所以我很喜欢看电子书（可惜大多数人都没有看电子书的习惯）。你如果还没有形成看电子书习惯的话，要开始培养了。<br />&#12288;&#12288;说完电子版和纸版，再来聊聊中文版和英文版。英文版相对中文版的优势就如同电子版相对纸版的优势一样明显。国内懂开发又文笔好的IT作家寥寥无几，导致国内出版的IT技术书籍要么翻译国外（翻译过程一般会导致1-2年的滞后、翻译质量还未必好），要么粗制滥造。所以，你如果不能流利地阅读英文书，赶紧恶补英语吧！<br /><br />&#12288;&#12288;上述4个招数，如能熟练运用，从此自学无忧矣！<br /><br /><br />下一个话题，准备聊一下“<a href="../../2009/01/3.html">设定个人发展目标和计划</a>”。<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/01/2.html">https://program-think.blogspot.com/2009/01/2.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/3.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>如何成为优秀开发人员[3]：设定个人发展目标和计划 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">如何成为优秀开发人员[3]：设定个人发展目标和计划</a></h1>
-<div class="post-info"><span class="date-header">2009-01-22</span><a href="../../tags/E8818CE59CBAE782B9E6BBB4.html" class="tag">职场点滴</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;大部分人从来没有【明确】地设定自己的发展目标，每天都是得过且过。等到几年过去了，才发现自己这些年啥也没学会，还是老样子，然后就感叹时光飞逝、岁月如梭。<br />&#12288;&#12288;因此，今天我们来聊一下如何设定个人发展目标。（如果你平时已经很善于定期设定个人发展目标并执行得很好，恭喜你，那么本帖子你可以略过）<a name='more'></a><!--program-think--><br /><br /><br /><h2>★个人发展目标</h2><br />&#12288;&#12288;先说说什么是【个人发展目标】。顾名思义，就是和你个人的职业发展有关的目标，包括知识、技能、工作岗位等都可以被设定为个人发展目标。（由于本博客主要关注IT方面，因此我会以个人的技术发展为例来说明，但是这些方法也适用于其他方面，例如个人财务目标）<br /><br /><br /><h2>★个人发展目标的三种类型</h2><br />我一般会把个人发展目标分为“长、中、短”三种类型，以此来对应不同的时间阶段。不管是哪种类型的目标，都要做到如下：<br />1. 要把目标设置得【难易适中】。太容易的目标对自己的成长帮助不够大；而太难的目标则容易中途放弃或者超出时间（导致打乱计划）。<br />2. 设定的目标要尽量容易评估（否则到时候连自己也搞不清楚到底目标算不算已达到）。<br /><br /><h3>◇短期目标</h3><br />&#12288;&#12288;先说说短期目标。短期目标的时间跨度大约在几个星期到一个季度之间。短期目标要定得比较具体，便于自己评估目标是否达成。<br />&#12288;&#12288;下面举几个短期目标的例子：“在本月读完《Thinking in C++》”、“在本月熟悉 Spring 框架”、“在这2个月用 C++ 写一个五子棋游戏”......<br /><br /><h3>◇中期目标</h3><br />&#12288;&#12288;然后说说中期目标。中期目标的时间跨度大约在几个季度到1-2年。中期目标比短期目标更抽象，且必须是短期目标的有机结合。<br />&#12288;&#12288;比如有个短期目标是“本周看完《Dive into Python》”，那么对应的中期目标可以是“1年内成为熟练的 Python 程序员”。<br /><br /><h3>◇长期目标</h3><br />&#12288;&#12288;最后谈谈长期目标。长期目标同样也必须和中级目标沾边，它的层次当然更高，时间跨度大约在5年以上。<br />&#12288;&#12288;而且长期目标一般不会关系到具体的XX语言、XX平台等，倒是经常和职业岗位有一定的关联。比如“5-7年内成为技术总监”、“5年内成为公司产品的架构师”等。<br /><br /><br /><h2>★个人发展计划</h2><br />&#12288;&#12288;当你把3种目标都设定好之后，就形成了【个人发展计划】。既然是计划，你就得在每一个阶段结束时自己总结一下，评估一下该目标的完成情况好不好，有什么收获、有什么经验教训。必要的话还需对尚未开始的后续目标进行一下调整。定期回顾还有一个好处，就是能获得一种满足感，从而有利于你坚持完整个计划。<br />&#12288;&#12288;关于“设定个人发展目标和计划”，今天就聊这么多。不管你是尚未毕业的在校生，还是已经工作多年的老员工（亡羊补牢还不晚），【从现在开始】，按照我上面说的，赶紧计划一下吧！<br /><br /><br />下一个话题，打算聊一下“<a href="../../2009/01/4.html">做正确的事</a>”。<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/01/3.html">https://program-think.blogspot.com/2009/01/3.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/4.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>如何成为优秀开发人员[4]：做正确的事 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">如何成为优秀开发人员[4]：做正确的事</a></h1>
-<div class="post-info"><span class="date-header">2009-01-27</span><a href="../../tags/E8818CE59CBAE782B9E6BBB4.html" class="tag">职场点滴</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;一般来说，优秀的开发人员往往具有较高的效率。俺这里提到的【效率】包括两方面：“做正确的事”和“正确地做事”。并且“做正确的事”比“正确地做事”更加重要。<a name='more'></a><!--program-think--><br /><br /><br /><h2>★一些不好的习惯</h2><br />&#12288;&#12288;咱们先来看一些反面教材。据相关研究机构统计，大部分人（80%以上）具有如下【不好】的工作习惯：<br /><blockquote>先做自己喜欢的事情，再做自己不喜欢的事情<br />先做紧急的事情，再做不紧急的事情<br />先做容易做的事情，再做不容易做的事情<br />先做自己了解、熟悉的事情，再做自己不了解、不熟悉的事情<br />先做有趣的事情，再做枯燥的事情<br />先做易于告一段落的事情，再做不易于告一段落的事情<br />先做自己熟悉的人托付的事情，再做自己不熟悉的人托付的事情</blockquote><br /><h2>★如何克服？</h2><br /><h3>◇评估权重</h3><br />&#12288;&#12288;你仔细回想一下，自己是否有上述的坏毛病？（我相信大多数人都有）如果你有其中的几项的话，你平时会很容易被琐事纠缠，白白浪费不少时间，每天忙完了都不清楚忙些啥。那怎么改变这种局面捏？听我细细道来。<br />&#12288;&#12288;“做正确的事”的关键在于评估你准备做的每件事情的【权重】。权重来源于这件事情对于达成目标是否有帮助？帮助有多大？<br />&#12288;&#12288;（咱们在本系列上一篇帖子《<a href="../../2009/01/3.html">设定个人发展目标和计划</a>》已经谈到如何设定目标）<br />&#12288;&#12288;如果某个事情对目标的帮助越大，则此事的权重越大；反之亦然。<br /><br /><h3>◇严格按照权重执行</h3><br />&#12288;&#12288;然后，每天醒来，你都要把当天准备做的事情根据权重排好优先级，然后【严格】按照优先级顺序执行。<br />&#12288;&#12288;如果工作中偶尔碰上看起来紧急的突发事情，也【不要】轻易改变原先安排的计划表，而要先冷静评估一下这个紧急的事情的权重。只有属于紧急且权重高（重要）的突发事件，你才可以调整计划，把这件突发事情加入其中。<br />&#12288;&#12288;关于重要性和紧急性的平衡与处理，在<a href="https://zh.wikipedia.org/wiki/%E5%BD%BC%E5%BE%97%C2%B7%E5%BE%B7%E9%B2%81%E5%85%8B" target="_blank" rel="nofollow">杜拉克</a>的名著《卓有成效的管理者》中有详细的介绍，大伙儿如果有兴趣可以去看看。<br />&#12288;&#12288;上面说的这些，看起来简单，但是真的操作起来挺难的。能否修炼成功得看各自的造化了。一般来说，【理性】的人比【感性】的人胜算更大。如果你是一个感性的人，那更得多努力了。<br /><br />&#12288;&#12288;聊完了“做正确的事”，下一个话题说一说“<a href="../../2009/02/5.html">正确地做事</a>”。<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/01/4.html">https://program-think.blogspot.com/2009/01/4.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/choose-it-book.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>如何选择 IT 技术书籍 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">如何选择 IT 技术书籍</a></h1>
-<div class="post-info"><span class="date-header">2009-01-21</span><a href="../../tags/IT.html" class="tag">IT</a> <a href="../../tags/E4B9A6E8AF842FE5BDB1E8AF84.html" class="tag">书评/影评</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;俺在《<a href="../../2009/01/2.html">如何成为优秀开发人员[2]：关于自学能力</a>》中提到阅读【好的】IT 技术书籍的重要性。今天来聊一下技术书籍的鉴定方法。假设你刚下了某本电子书准备看，又或者逛书店看到某本纸版书准备买，但是吃不准该书的质量如何，那么下面几个招数可以帮你的忙。<a name='more'></a><!--program-think--><br /><br /><br /><h2>★第1招：看网上评论</h2><br />&#12288;&#12288;首先，上一些权威的图书网站，看看大伙儿的评价如何（要相信群众的眼睛是雪亮的）。对于英文书籍，我一般上<a href="http://www.amazon.com/" target="_blank" rel="nofollow">亚马逊网站</a>去看看；中文书籍则上<a href="http://www.douban.com/" target="_blank" rel="nofollow">豆瓣网</a>。这两个网站都提供星级评分，一般 ＞=4星 的评级都不差。（此招数对于正在逛书店的不一定适用，除非你随身带了上网的东东）<br /><br /><br /><h2>★第2招：看作者</h2><br />&#12288;&#12288;书籍作者的重要性无需多说。根据<a href="../../2009/02/80-20-principle-0-overview.html">二八原理</a>，大部分的好书都是少数优秀作者写出来的。如果作者是该领域的技术大牛或者知名评论家，那么该书的质量一般不会太差。<br />&#12288;&#12288;不过捏，想用这招，你先得对这本书所在的领域有一定的了解，知道哪些人属于该领域的大牛。<br /><br /><br /><h2>★第3招：看出版信息</h2><br />&#12288;&#12288;出版信息里面，主要看出版社、出版时间。好的出版社出的书，总体水平还过得去，不至于太滥，排版印刷错误也较少。<br />&#12288;&#12288;出版时间的重要性得看具体的领域。比如某些领域（算法、软件工程等）的书，对于时间不敏感。即使年代久远也没有过时（比如<a href="../../2009/03/book-review-mythical-man-month.html">人月神话</a>发表于1975年）。而另一些领域（涉及具体的语言、软件、操作系统）则需要与时俱进，3-5年之前出版的书可能就已经过时了。<br />&#12288;&#12288;如果是纸版书，还可以看看再版次数和印数。这两个指标一般和销量成正比。不过也不排除少数阳春白雪的好书，销量很低。因此这两个指标仅供参考。<br /><br /><br /><h2>★第4招：看目录</h2><br />&#12288;&#12288;看完出版信息后，就可以大致看看目录。从目录可以了解到很多信息。好书的目录一般层次分明、条理清晰。滥书则反之。<br />&#12288;&#12288;看目录还可以在最短时间内大致了解该书的深浅以及内容的分布（看每一章占了多少页），从而判断这本书能否适合自己。<br />&#12288;&#12288;比如，我曾经看过一本国内作者写的《面向对象 Java 编程》。打开目录扫了一下，整本书都是讲 Java 语法，只在其中一章提到了面向对象，页数占全书比例不到10%（我强烈怀疑作者是否直接拿了 SUN 的 Java 语言规范汉化了一下，就拿去出版了）。<br /><br /><br /><h2>★第5招：抽查几页</h2><br />&#12288;&#12288;最后，可以挑书中的某个小节看一下。看看作者的文笔是否流畅、生动。如果是翻译的书，则还要注意一下翻译的水平如何。翻译的书的质量<b>同时</b>取决于作者和译者的水平，任何一个不行，整本书就好不到哪里去。<br />&#12288;&#12288;当年学 MFC 的时候，曾看过一本翻译的书，把 MFC 的“doc/view”翻译成"文档查看"，当场厥倒。所以有条件看看原著（你的洋文够牛）的同学就尽量看原著，免得被差劲的译者带到沟里。<br /><br /><br />&#12288;&#12288;IT 技术书籍的选择就暂且聊到这里。以后，我打算不定期地推荐一些经典的书籍给列位看官。和书评相关的帖子都在<a href="https://program-think.blogspot.com/search/label/%E4%B9%A6%E8%AF%84%2F%E5%BD%B1%E8%AF%84">这里</a>。<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/01/choose-it-book.html">https://program-think.blogspot.com/2009/01/choose-it-book.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/cxx-coding-standards-101-rules.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>书评：《C++ 101编程规范》 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">书评：《C++ 101编程规范》</a></h1>
-<div class="post-info"><span class="date-header">2009-01-22</span><a href="../../tags/E4B9A6E8AF842FE5BDB1E8AF84.html" class="tag">书评/影评</a> <a href="../../tags/E7BC96E7A88B.html" class="tag">编程</a> <a href="../../tags/E7BC96E7A88B.C.html" class="tag">编程.C</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;今天是头一次聊 C++ 的书，当然要选一本够分量又实用的书。俺想了一炷香的功夫，决定先拿《C++ Coding Standards: 101 Rules, Guidelines, and Best Practices 》开刀。<a name='more'></a><!--program-think--><br />&#12288;&#12288;上次俺在《<a href="../../2009/01/choose-it-book.html">如何选择 IT 技术书籍</a>》中已经介绍了几个鉴别好书的招数，现在可以验证一下。<br /><br />&#12288;&#12288;先说说此书的作者 Herb Sutter 和 Andrei Alexandrescu。两位都是 C++ 社区的大牛。其中 Herb Sutter 是标准委员会的主席（光看头衔就知道有多牛了）。Andrei Alexandrescu 是《Modern C++ Design》的作者，大凡看过此书的人应该都会被他极具创新的 C++ 模板用法所震惊。鉴于两位作者的分量，大伙儿可以想见该书一定不差。<br />&#12288;&#12288;然后看看出版时间是2004年，在 C++ 98 和 C++ 03 标准之后，因此肯定已经涵盖了 C++ 语言新标准的东东。本书的出版社“Addison Wesley”也是国际知名。因此从“出版信息”看，这本书也符合要求。<br />&#12288;&#12288;再然后，看看目录。在本书之前，俺曾看过许多关于编码规范的书或者文章，但是都仅仅局限于语法层面。而这本书的出众之处在于用了很大的比重来介绍语法之外的条款（例如性能优化、类设计、STL 库的使用）。由此看来，本书可以适合不同层次的 C++ 开发人员，即使你是用 C++ 写了多年程序的老手也会从中获益。<br /><br />&#12288;&#12288;啰嗦了一大堆好处（你估计看烦了），现在开始来具体介绍一下内容。全书的101个条款分布在如下的12部分中，下面来挨个介绍一下。（如果你已经通读过全书，后面内容你可以略过）<br /><br /><b>1、组织与策略</b><br />这部分其实不是讲 C++，而是更偏向于软件工程方面。如果你是一个部门或者团队的主管，要仔细思考一下：这些条款你的团队/部门是否都做到了？如果你是一个 C++ 新手，可以先略过这部分。<br /><br /><b>2、设计风格</b><br />这部分讲的是通用程序设计哲学，并不限于 C++，而是适用于所有的编程语言。如果你对 C++ 已经入门，但是想再上一个境界，本部分你必须好好领会。我估计有十年编程经验的老手也未必能够完全吃透该部分的所有条款。<br /><br /><b>3、编码风格</b><br />终于开始说到C++语法了！本部分说得都是一些基本的东东，C++ 新手要好好看看这部分，老手倒未必了。<br /><br /><b>4、函数与操作符（运算符）</b><br />如果你是从其它语言 Java 和 C 转到 C++，可能对操作符重载还不适应，需要了解一下这部分。如果你原来是 Python 程序员，估计对操作符重载，应该会比较有亲切感。<br /><br /><b>5、类设计和继承</b><br />最好你已经有了一定的 OOP 理论功底，然后再来看这部分，效果会更好。<br /><br /><b>6、构造、析构、拷贝</b><br />这部分读起来的难度不大。不过有几个几个细节需要注意（即使你已是熟手）。<br /><br /><b>7、名空间和模块</b><br />如果你需要从事规模比较大的 C++ 项目的开发，那么本部分一定要了解一下。比较大的项目一般都会涉及到逻辑分割（切分名空间）和物理分割（划分模块）。<br /><br /><b>8、模板与范型</b><br />这部分适合已经比较熟悉 C++ 的开发人员，新手可以先略过。<br /><br /><b>9、错误处理与异常</b><br />错误和异常的处理，是编程领域公认的难点。头几条是关于原理性的条款（因此也适用于其它语言），需要深刻领会；后几条是关于 C++ 语法，你如果对 try/catch 不熟悉的话要注意看看了（即使是2-3年开发经验的，也有许多不熟悉异常处理）。<br /><br /><b>10、STL 容器 & 11、STL 算法</b><br />如果你是从其它语言（Java、C）转到 C++，或者你原先只用MFC，那么估计你的 STL 会有欠缺，好好看看这两部分吧。<br /><br /><b>12、类型安全</b><br />如果你是从 C 转到 C++，这部分尤其要注意看一下。里面提到的几个条款都是和C的缺点有关（这么说，C 语言的 fans 看了可别动怒啊）。<br /><br />&#12288;&#12288;听完俺滴介绍，感觉怎么样？想去弄一本来看看吗？<br />&#12288;&#12288;此书的电子版已经上传到网盘。想看的同学，请猛击“<a href="https://github.com/programthink/books" target="_blank">俺收藏的电子书目录</a>”。<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/01/cxx-coding-standards-101-rules.html">https://program-think.blogspot.com/2009/01/cxx-coding-standards-101-rules.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/cxx-cross-platform-develop-0-overview.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>C++ 的可移植性和跨平台开发[0]：概述 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">C++ 的可移植性和跨平台开发[0]：概述</a></h1>
-<div class="post-info"><span class="date-header">2009-01-26</span><a href="../../tags/E7BC96E7A88B.html" class="tag">编程</a> <a href="../../tags/E7BC96E7A88B.C.html" class="tag">编程.C</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;今天聊聊 C++ 的可移植性问题。如果你平时使用 C++ 进行开发，并且你对 C++ 的可移植性问题不是非常清楚，那么建议你看看这个系列。即使你目前没有跨平台开发的需要，了解可移植性方面的知识对你还是很有帮助的。<a name='more'></a><!--program-think--><br />&#12288;&#12288;C++ 的可移植性这个话题很大，包括了编译器、操作系统、硬件体系等很多方面，每一个方面都有很多内容。鉴于本人能力、精力都有限，只能介绍每一个方面最容易碰到的问题，供大伙儿参考。<br />&#12288;&#12288;后面我会分别从编译器、C++ 语法、操作系统、第三方库、辅助工具、开发流程等方面进行介绍。<br /><br /><a name="index"> </a><br />为了方便阅读，把本系列帖子的目录整理如下：<br />1. <a href="../../2009/01/cxx-cross-platform-develop-1-compiler.html">编译器</a><br />2. <a href="../../2009/01/cxx-cross-platform-develop-2-language.html">语法</a><br />3. <a href="../../2009/01/cxx-cross-platform-develop-3-exception.html">异常处理</a><br />4. <a href="../../2009/01/cxx-cross-platform-develop-4-hardware.html">硬件体系</a><br />5. <a href="../../2009/02/cxx-cross-platform-develop-5-os.html">操作系统</a><br />6. <a href="../../2009/04/cxx-cross-platform-develop-6-thread.html">多线程</a><br />7. （未完待续）<br /><br /><br /><b>俺博客上，和本文相关的帖子（需翻墙）</b>：<br />《<a href="../../2012/05/weekly-share-5.html">每周转载：IT 大牛谈编程语言（网文3篇）</a>》<br />《<a href="../../2009/01/0.html">如何成为优秀开发人员</a>》（系列）<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/01/cxx-cross-platform-develop-0-overview.html">https://program-think.blogspot.com/2009/01/cxx-cross-platform-develop-0-overview.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/cxx-cross-platform-develop-1-compiler.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>C++ 的可移植性和跨平台开发[1]：编译器 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">C++ 的可移植性和跨平台开发[1]：编译器</a></h1>
-<div class="post-info"><span class="date-header">2009-01-26</span><a href="../../tags/E7BC96E7A88B.html" class="tag">编程</a> <a href="../../tags/E7BC96E7A88B.C.html" class="tag">编程.C</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;在跨平台的开发过程中，很多问题都和编译器有关。因此我们先来聊聊编译器相关的问题。<a name='more'></a><!--program-think--><br /><br /><br /><h2>★编译器的选择</h2><br />&#12288;&#12288;首先，GCC 是优先要考虑支持的，因为几乎所有操作系统平台都有 GCC 的实现。它基本上成了一个通用的编译器了。如果你的代码在 A 平台的 GCC 能够编译通过，之后拿到 B 平台用类似版本的 GCC 编译，一般也不会有太大问题。因此 GCC 是肯定要考虑支持的。<br />&#12288;&#12288;其次，要考虑是否支持本地编译器。所谓本地编译器就是操作系统厂商自产的编译器。<br />&#12288;&#12288;举例来说：<br />相对于 Windows 的本地编译器就是 Visual C++<br />相对于 Solaris 的本地编译器就是 SUN 的 CC<br />&#12288;&#12288;如果你对性能比较敏感或者想用到某些本地编译器的高级功能，可能就得考虑在支持 GCC 的同时也支持本地编译器。<br /><br /><br /><h2>★编译警告</h2><br />&#12288;&#12288;编译器是程序员的朋友，很多潜在的问题（包括可移植性），编译器都是可以发现并给出警告的。如果你平时注意这些警告信息，可以减少很多麻烦。<br />&#12288;&#12288;因此俺强烈建议：<br />1. 把编译器的警告级别调高；<br />2. 【不要】轻易忽略编译器的警告信息。<br /><br /><br /><h2>★交叉编译器</h2><br />&#12288;&#12288;从没听说过“交叉编译器”的同学，可以先看“<a href="https://en.wikipedia.org/wiki/Cross-compiling" target="_blank" rel="nofollow">维基百科的介绍</a>”。<br />&#12288;&#12288;通俗地说，就是在 A 平台上编译出运行在 B 平台上的二进制程序。假设你要开发的应用是运行在 Solaris上，但是你手头没有能够运行 Solaris的 SPARC 机器，这时候交叉编译器就可以派上用场了。一般情况下都使用 GCC 来制作一个交叉编译器，限于篇幅，这里就不深入聊了。有兴趣的同学可以参见“<a href="http://www.nongnu.org/thug/cross.html" target="_blank" rel="nofollow">这篇文档</a>”。<br /><br />&#12288;&#12288;关于编译器的话题，暂时聊到这，后面聊聊关于“<a href="../../2009/01/cxx-cross-platform-develop-2-language.html">语法</a>”的问题。<br /><br /><br /><a href="../../2009/01/cxx-cross-platform-develop-0-overview.html#index">回到本系列的目录</a><br /><div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/01/cxx-cross-platform-develop-1-compiler.html">https://program-think.blogspot.com/2009/01/cxx-cross-platform-develop-1-compiler.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/cxx-cross-platform-develop-2-language.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>C++ 的可移植性和跨平台开发[2]：语法 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">C++ 的可移植性和跨平台开发[2]：语法</a></h1>
-<div class="post-info"><span class="date-header">2009-01-28</span><a href="../../tags/E7BC96E7A88B.html" class="tag">编程</a> <a href="../../tags/E7BC96E7A88B.C.html" class="tag">编程.C</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;目前还有相当一部分开发人员在使用老式编译器干活，这些老式编译器可能对C++98支持不够。因此，当你的代码移植到这些老式的编译器上时，可能会碰到一些稀奇古怪的问题（包括编译出错和运行时错误）。下面这些注意事项有助于你绕过这些问题。<br />强调一下，后面提到的好几个条款都是通过回避C++的新语法来保证移植性。如果你用的是新式编译器，那么你可以不理会这些条款。<a name='more'></a><!--program-think--><br /><br /><br /><h2>★小心 for 循环变量的作用域（不支持新标准）</h2><br />&#12288;&#12288;在 C++ 98 标准中，for 循环变量的作用域局限在循环体内。但某些老的编译器（例如Visual C++ 6）认为 for 循环变量的作用域在循环体外。所以如下的代码可能导致移植问题。<br /><div class="source"><pre><span></span><span class="p">{</span><br />    <span class="k">for</span><span class="p">(</span><span class="kt">int</span> <span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span> <span class="n">i</span><span class="o">&lt;</span><span class="n">XX</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span><br />    <span class="p">{</span><br />        <span class="c1">// ...</span><br />    <span class="p">}</span><br /><br />    <span class="k">for</span><span class="p">(</span><span class="kt">int</span> <span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span> <span class="n">i</span><span class="o">&lt;</span><span class="n">XXX</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span><br />    <span class="p">{</span><br />        <span class="c1">// ...</span><br />    <span class="p">}</span><br /><span class="p">}</span><br /></pre></div><br />&#12288;&#12288;建议修改为【不同的】循环变量名，如下所示：<br /><div class="source"><pre><span></span><span class="p">{</span><br />    <span class="k">for</span><span class="p">(</span><span class="kt">int</span> <span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span> <span class="n">i</span><span class="o">&lt;</span><span class="n">XX</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span><br />    <span class="p">{</span><br />        <span class="c1">// ...</span><br />    <span class="p">}</span><br /><br />    <span class="k">for</span><span class="p">(</span><span class="kt">int</span> <span class="n">j</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span> <span class="n">j</span><span class="o">&lt;</span><span class="n">XXX</span><span class="p">;</span> <span class="n">j</span><span class="o">++</span><span class="p">)</span><br />    <span class="p">{</span><br />        <span class="c1">// ...</span><br />    <span class="p">}</span><br /><span class="p">}</span><br /></pre></div><br /><br /><h2>★不要使用全局类对象，改用单键（标准未定义）</h2><br />&#12288;&#12288;全局类对象的构造函数先于 main() 函数执行，如果某个模块中同时包含若干个全局类对象，则它们的构造函数的调用顺序是【不确定】的。而单键是在第一次调用时被初始化，能避免此问题。另外，单键虽然解决了构造问题，但是析构依然有隐患。更多介绍请看《<a href="../../2009/02/cxx-object-destroy-overview.html">C++ 对象是怎么死的？</a>》系列博文。<br /><br /><br /><h2>★保持 inline 函数尽量简单</h2><br />&#12288;&#12288;【不要】在 inline 函数内部使用局部静态变量，【不要】在 inline 函数使用可变参数。<br />&#12288;&#12288;因为这些做法有可能导致可移植性的问题。<br /><br /><br /><h2>★不要依赖函数参数的求值顺序（标准未定义）</h2><br />&#12288;&#12288;C++ 标准【没有】明确规定函数参数的求值顺序。因此，如下的代码行为是不确定的。<br /><div class="source"><pre><span></span><span class="kt">void</span> <span class="nf">Foo</span><span class="p">(</span><span class="kt">int</span> <span class="n">a</span><span class="p">,</span> <span class="kt">int</span> <span class="n">b</span><span class="p">);</span><br /><span class="kt">int</span> <span class="n">n</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span><br /><span class="n">foo</span><span class="p">(</span><span class="o">++</span><span class="n">n</span><span class="p">,</span> <span class="o">++</span><span class="n">n</span><span class="p">);</span><br /></pre></div><br /><br /><h2>★慎用模板特化（不支持新标准）</h2><br />&#12288;&#12288;某些【老式】编译器对“模板偏特化”或“模板全特化”支持不够。<br />&#12288;&#12288;举例：VC6 不支持“模板偏特化”。<br /><br /><br /><h2>★模板继承中，引用基类成员要小心（不支持新标准）</h2><br />&#12288;&#12288;为了直观，给出如下例子：<br /><div class="source"><pre><span></span><span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">T</span><span class="o">&gt;</span><br /><span class="k">class</span> <span class="nc">TBase</span><br /><span class="p">{</span><br /><span class="k">protected</span><span class="o">:</span><br />    <span class="k">typedef</span> <span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span> <span class="n">Container</span><span class="p">;</span><br />    <span class="n">Container</span> <span class="n">m_container</span><span class="p">;</span><br /><span class="p">};</span><br /><br /><span class="k">template</span> <span class="o">&lt;</span><span class="k">typename</span> <span class="n">T</span><span class="o">&gt;</span><br /><span class="k">class</span> <span class="nc">TDerived</span> <span class="o">:</span> <span class="k">public</span> <span class="n">TBase</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span><br /><span class="p">{</span><br />    <span class="k">typedef</span> <span class="n">TBase</span><span class="o">&lt;</span><span class="n">T</span><span class="o">&gt;</span> <span class="n">BaseClass</span><span class="p">;</span><br /><br /><span class="k">public</span><span class="o">:</span><br />    <span class="kt">void</span> <span class="n">Func</span><span class="p">()</span><br />    <span class="p">{</span><br />        <span class="k">typename</span> <span class="n">BaseClass</span><span class="o">::</span><span class="n">Container</span> <span class="n">foo</span><span class="p">;</span>  <span class="c1">// 可移植</span><br />        <span class="n">Container</span> <span class="n">foo</span><span class="p">;</span>  <span class="c1">// 【不】可移植</span><br />        <span class="k">this</span><span class="o">-&gt;</span><span class="n">m_container</span><span class="p">.</span><span class="n">clear</span><span class="p">();</span> <span class="c1">// 可移植</span><br />        <span class="n">m_container</span><span class="p">.</span><span class="n">clear</span><span class="p">();</span> <span class="c1">// 【不】可移植</span><br />    <span class="p">}</span><br /><span class="p">};</span><br /></pre></div><br /><br /><h2>★慎用 RTTI（不支持新标准、标准未定义）</h2><br />&#12288;&#12288;（先声明一下，俺这里说的 RTTI 主要是指 typeid 操作符和 type_info 类型）<br />&#12288;&#12288;首先，由于某些老式编译器可能不支持 typeid 操作符和 type_info 类型，会导致移植性的问题，这是慎用 RTTI 的一个原因。（如果你用的是新式编译器，不用考虑这个因素）<br />&#12288;&#12288;其次，由于标准对于 type_info 类型的约束比较简单。这导致了不同的编译器对 type_info 的实现有较大差异。如果你确实要使用 type_info 类型，建议仅仅使用它的 operator== 和 operator!= 这两个成员函数（只有这两个函数是明确定义的）<br />&#12288;&#12288;所以，如果你确实需要在运行时确定类型，又不想碰到上述问题，可以考虑在自己的类体系中加入类型信息来实现。例如：MFC 和 <a href="http://www.wxwidgets.org/" target="_blank" rel="nofollow">wxWidgets</a> 都是这么干的。<br /><br /><br /><h2>★慎用嵌套类（不支持新标准）</h2><br />&#12288;&#12288;如果在内部类访问外部类的非公有成员，要把内部类声明为外部类的friend。<br />&#12288;&#12288;如下代码存在移植问题。<br /><div class="source"><pre><span></span><span class="k">class</span> <span class="nc">COuter</span><br /><span class="p">{</span><br /><span class="k">private</span><span class="o">:</span><br />    <span class="kt">char</span><span class="o">*</span> <span class="n">m_name</span><span class="p">;</span><br /><br /><span class="k">public</span><span class="o">:</span><br />    <span class="k">class</span> <span class="nc">CInner</span><br />    <span class="p">{</span><br />        <span class="kt">void</span> <span class="n">Print</span><span class="p">(</span><span class="n">COuter</span><span class="o">*</span> <span class="n">outer</span><span class="p">)</span><br />        <span class="p">{</span><br />            <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">outer</span><span class="o">-&gt;</span><span class="n">m_name</span><span class="p">;</span><br />        <span class="p">}</span><br />    <span class="p">};</span><br /><span class="p">};</span><br /></pre></div><br />应该改为如下代码：<br /><div class="source"><pre><span></span><span class="k">class</span> <span class="nc">COuter</span><br /><span class="p">{</span><br /><span class="k">private</span><span class="o">:</span><br />    <span class="kt">char</span><span class="o">*</span> <span class="n">m_name</span><span class="p">;</span><br /><br /><span class="k">public</span><span class="o">:</span><br />    <span class="k">class</span> <span class="nc">CInner</span><span class="p">;</span>  <span class="c1">// 前置声明</span><br />    <span class="k">friend</span> <span class="k">class</span> <span class="nc">CInner</span><span class="p">;</span><br /><br />    <span class="k">class</span> <span class="nc">CInner</span><br />    <span class="p">{</span><br />        <span class="kt">void</span> <span class="n">Print</span><span class="p">(</span><span class="n">COuter</span><span class="o">*</span> <span class="n">outer</span><span class="p">)</span><br />        <span class="p">{</span><br />            <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="n">outer</span><span class="o">-&gt;</span><span class="n">m_name</span><span class="p">;</span><br />        <span class="p">}</span><br />    <span class="p">};</span><br /><span class="p">};</span><br /></pre></div><br /><br /><h2>★不要定义参数类型相近的函数（标准未定义）</h2><br />&#12288;&#12288;先看如下代码：<br /><div class="source"><pre><span></span><span class="kt">void</span> <span class="nf">Foo</span><span class="p">(</span><span class="kt">short</span> <span class="n">n</span><span class="p">)</span><br /><span class="p">{</span><br />    <span class="c1">// ....</span><br /><span class="p">}</span><br />  <br /><span class="kt">void</span> <span class="nf">Foo</span><span class="p">(</span><span class="kt">long</span> <span class="n">n</span><span class="p">);</span><br /><span class="p">{</span><br />    <span class="c1">// ....</span><br /><span class="p">}</span><br /><br /><span class="n">Foo</span><span class="p">(</span><span class="mi">0</span><span class="p">);</span> <span class="c1">// 会导致二义性错误</span><br /></pre></div>&#12288;&#12288;假如没有出现最后一行的那个调用，光编译前面两个重载的 Foo 函数是【不会】出错的。这反而增加了该问题的隐蔽性。<br />&#12288;&#12288;下面俺来解释一下：<br />&#12288;&#12288;万一这两个 Foo 函数存在于某个公共函数库中，编译这个库都很正常。但是使用这个库的某个程序调用了 Foo(0); 结果就编译失败了。<br /><br /><br /><h2>★不要依赖标准类型的字长（标准未定义）</h2><br />&#12288;&#12288;某些标准类型（例如 int、wchar_t）的字长会随着具体的平台而改变。<br /><br /><br /><h2>★用枚举代替类的静态成员常量（不支持新标准）</h2><br />&#12288;&#12288;某些【老式】的编译器不支持类的静态成员常量，可以用枚举来代替。<br /><div class="source"><pre><span></span><span class="k">class</span> <span class="nc">CFoo</span><br /><span class="p">{</span><br />    <span class="k">static</span> <span class="k">const</span> <span class="kt">int</span> <span class="n">MIN</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>  <span class="c1">// 【不】可移植</span><br />    <span class="k">enum</span> <span class="p">{</span> <span class="n">MAX</span> <span class="o">=</span> <span class="mi">64</span> <span class="p">};</span>  <span class="c1">// 可移植</span><br /><span class="p">};</span><br /></pre></div><br /><br /><h2>★结尾</h2><br />&#12288;&#12288;今天说了这么一大堆，都比较琐碎，估计会有遗漏的。日后如果大伙儿发现有补充的，欢迎在本帖的评论中指教一二。<br />&#12288;&#12288;由于篇幅有限，和异常相关的内容留到<a href="../../2009/01/cxx-cross-platform-develop-3-exception.html">下一个话题</a>来聊。<br /><br /><br /><a href="../../2009/01/cxx-cross-platform-develop-0-overview.html#index">回到本系列的目录</a><div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/01/cxx-cross-platform-develop-2-language.html">https://program-think.blogspot.com/2009/01/cxx-cross-platform-develop-2-language.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/cxx-cross-platform-develop-3-exception.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>C++ 的可移植性和跨平台开发[3]：异常处理 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">C++ 的可移植性和跨平台开发[3]：异常处理</a></h1>
-<div class="post-info"><span class="date-header">2009-01-30</span><a href="../../tags/E7BC96E7A88B.html" class="tag">编程</a> <a href="../../tags/E7BC96E7A88B.C.html" class="tag">编程.C</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;上一个帖子“<a href="../../2009/01/cxx-cross-platform-develop-2-language.html">语法</a>”由于篇幅有限，没来得及聊异常，现在把和异常相关的部分单独拿出来说一下。<a name='more'></a><!--program-think--><br /><br /><br /><h2>★小心 new 分配内存失败</h2><br />&#12288;&#12288;早期的老式编译器生成的代码，如果 new 失败会返回空指针。俺当年用的 Borland C++ 3.1 似乎就是这样的。如今这种编译器应该不多见了，万一你在用的编译器还有这种行为，那你就惨了。碰到这种老式编译器，可以考虑重载 new 操作符来抛出 bad_alloc 异常，便于进行异常处理。<br />&#12288;&#12288;稍微新式一点的编译器，就不是仅仅返回空指针了。当 new 操作符发现内存告急，按照标准的规定（参见 C++ 03 标准 18.4.2章节），它应该去调用 new_handler 函数（原型为 typedef void (*new_handler)();）。标准建议 new_handler 函数干如下三件事：<br />1. 设法去多搞点内存来<br />2. 抛出 bad_alloc 异常<br />3. 调用 C++ 标准库的 abort() 或 exit() 来退出进程<br />&#12288;&#12288;由于 new_handler 函数是可以被重新设置的（通过调用 set_new_handler），所以上述几种行为都可能出现。<br /><br />&#12288;&#12288;综上所述，new 分配内存失败，有可能三种可能：<br />1. 返回空指针<br />2. 抛出异常<br />3. 进程立即终止<br />&#12288;&#12288;如果你希望你的代码具有较好的移植性，你就得把这三种情况都考虑到。<br /><br /><br /><h2>★慎用异常规格</h2><br />&#12288;&#12288;异常规格在俺看来不是一个好东西，不信可以去看看《<a href="../../2009/01/cxx-coding-standards-101-rules.html">C++ Coding Standards - 101 Rules, Guidelines &amp; Best Practices</a>》的第75条。（具体有哪些坏处以后专门开一个 C++ 异常和错误处理的帖子来聊）<br />&#12288;&#12288;言归正传，按照标准（参见 C++ 03 标准 18.6.2章节），如果一个函数抛到外面的异常没有包含在该函数的异常规范中，那么应该调用 unexcepted()。但是并非所有编译器生成的代码都遵守标准（比如某些版本的 VC 编译器）。如果你的需要支持的编译器在异常规范上的行为不一致，那就得考虑：从你的代码中去掉所有的异常规范声明。<br /><br /><br /><h2>★不要跨模块抛出异常</h2><br />&#12288;&#12288;（先声明：此处说的“模块”是指动态库）<br />&#12288;&#12288;如果你的工程中包含了动态库，【不要】把异常抛到模块的导出函数之外。<br />&#12288;&#12288;毕竟现在 C++ 还没有 ABI 标准（估计将来也未必会有），跨模块抛出异常会有很多不可预料的行为。<br /><br /><br /><h2>★不要使用结构化异常处理（SEH）</h2><br />&#12288;&#12288;如果你从来没有听说过 SEH，那就当俺没说，跳过这段。<br />&#12288;&#12288;如果你以前习惯于用 SEH，在你打算写跨平台代码之前，要改掉这个习惯。包含有 SEH 的代码只能在 Windows 平台上编译通过（肯定无法跨平台的）。<br /><br /><br /><h2>★关于 catch(...)</h2><br />&#12288;&#12288;照理说，catch(...) 语句只能够捕获 C++ 的异常类型，对于访问违例、除零错等非 C++ 异常是无能为力的。但是某些情况下（比如某些 VC 编译器），诸如“访问违例、除零错”之类的异常，也可以被 catch(...) 所捕获。<br />&#12288;&#12288;所以，你如果希望代码的可移植性好，就不能在程序逻辑中依赖上述 catch(...) 的行为——换句话说：你【不能】指望 catch(...) 来捕获“访问违例、除零错”之类的非 C++ 异常。<br /><br />&#12288;&#12288;下一个帖子，准备聊一下和“<a href="../../2009/01/cxx-cross-platform-develop-4-hardware.html">硬件有关的跨平台问题</a>”。<br /><br /><br /><a href="../../2009/01/cxx-cross-platform-develop-0-overview.html#index">回到本系列的目录</a><div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/01/cxx-cross-platform-develop-3-exception.html">https://program-think.blogspot.com/2009/01/cxx-cross-platform-develop-3-exception.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/cxx-cross-platform-develop-4-hardware.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>C++ 的可移植性和跨平台开发[4]：硬件体系 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">C++ 的可移植性和跨平台开发[4]：硬件体系</a></h1>
-<div class="post-info"><span class="date-header">2009-01-31</span><a href="../../tags/E7BC96E7A88B.html" class="tag">编程</a> <a href="../../tags/E7BC96E7A88B.C.html" class="tag">编程.C</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;这次聊的话题主要是和硬件体系有关的。比如你的程序需要支持不同类型的 CPU（x86、SPARC、PowerPC），或者是同种类型不同字长的 CPU（比如 x86、amd64），这时候你就需要关心一下硬件体系的问题。<a name='more'></a><!--program-think--><br /><br /><br /><h2>★基本类型的大小</h2><br />&#12288;&#12288;C++ 中基本类型的大小（占用的字节数）会随着 CPU 字长的变化而变化。<br />&#12288;&#12288;所以，假如你要表示一个 int 占用的字节数，千万不要直接写“<b>4</b>”（顺便说一下，直接写“<b>4</b>”还犯了 Magic Number 的大忌，详见<a href="../../2009/02/defect-of-java-beginner-3-code-style.html#magic_number">这篇</a>），而应该写“<b>sizeof(int)</b>”；<br />&#12288;&#12288;反过来，如果你要定义一个大小【必须】为4字节的有符号整数，也不要直接用 int，而要用预先 typedef 好的【定长】类型（比如 <a href="http://www.boost.org/" target="_blank" rel="nofollow">boost</a> 库提供的 int32_t、<a href="http://www.cs.wustl.edu/%7Eschmidt/ACE.html" target="_blank" rel="nofollow">ACE</a> 库提供的 ACE_INT32 ...）。<br />&#12288;&#12288;差点忘了，指针的大小也有上述的问题，也要小心。<br /><br /><br /><h2>★字节序</h2><br />&#12288;&#12288;如果你没听说过“字节序”这玩意儿，请看“<a href="https://en.wikipedia.org/wiki/Endianness" target="_blank" rel="nofollow">维基百科</a>”。<br />&#12288;&#12288;通俗地打个比方，在一个大尾序的机器上有一个4字节的整数 0x01020304，通过网络或者文件传到一台小尾序的机器上就会变成 0x04030201；据说还有一种中尾序的机器（不过我没接触过），上述整数会变成 0x02010403。<br />&#12288;&#12288;如果你编写的应用程序中涉及网络通讯，一定要在记得进行主机序和网络序的翻译；如果涉及跨机器传输二进制文件，也要记得进行类似的转换。<br /><br /><br /><h2>★内存对齐</h2><br />&#12288;&#12288;如果你不晓得“内存对齐”是什么东东，请看“<a href="https://en.wikipedia.org/wiki/Data_structure_alignment" target="_blank" rel="nofollow">维基百科</a>”。<br />&#12288;&#12288;简单来说，出于 CPU 处理上的性能考虑，结构体中的数据不是紧挨着的，而是要空开一些间隔。这样的话，结构体中每个数据的地址正好都是某个字长的整数倍。<br />&#12288;&#12288;由于 C++ 标准中没有定义内存对齐的细节，因此，你的代码也不能依赖对齐的细节。凡是计算结构体大小的地方，都老老实实写上 sizeof()。<br />&#12288;&#12288;有些编译器支持 #pragma pack 预处理语句（可以用来修改对齐字长），不过这种语法【不是】所有编译器都支持，要慎用。<br /><br /><br /><h2>★移位操作</h2><br />&#12288;&#12288;对于有符号整数的右移操作，有些系统默认使用算数右移（最高的符号位不变），有些默认使用逻辑右移（最高的符号位补0）。所以，【不要】对【有符号】整数进行【右移】操作。<br />&#12288;&#12288;顺便说一下，即使没有移植性问题，代码中也尽量少用移位运算符。那些企图用移位运算来提高性能的同学更要注意了，这么干不但可读性很差，而且吃力不讨好——如今的编译器，只要不太弱智，都会自动帮你搞定这种优化，无须程序员来操心。<br /><br /><br />&#12288;&#12288;下一个帖子，准备聊一下“<a href="../../2009/02/cxx-cross-platform-develop-5-os.html">操作系统相关的跨平台问题</a>”。<br /><br /><br /><a href="../../2009/01/cxx-cross-platform-develop-0-overview.html#index">回到本系列的目录</a><div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/01/cxx-cross-platform-develop-4-hardware.html">https://program-think.blogspot.com/2009/01/cxx-cross-platform-develop-4-hardware.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/defect-of-java-beginner-0-overview.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>Java 新手的通病[0]：概述 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">Java 新手的通病[0]：概述</a></h1>
-<div class="post-info"><span class="date-header">2009-01-29</span><a href="../../tags/E7BC96E7A88B.html" class="tag">编程</a> <a href="../../tags/E7BC96E7A88B.Java.html" class="tag">编程.Java</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;其实很早以前就想写这样一个文章，可惜当时俺还没有开 Blog，所以到现在才写下来。最近几年，随着 Java 在 Web 应用和企业应用两个方面的普及，对 Java 程序员的需求量大增。因此Java程序员的数量也突然猛增（从<a href="http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html" target="_blank" rel="nofollow">TIOBE 的排行榜</a>可以看出来）。这虽然对 Java 社区来说是好事，但也暴露出一些问题。一方面由于大量的开发人员进入 Java 这个领域，相应的教学、培训跟不上；另一方面，很多进入 Java 领域的开发人员都比较浮躁，寄希望于"速成"，没有耐心练好基本功。<a name='more'></a><!--program-think--><br />&#12288;&#12288;根据最近几年我面试 Java 程序员的经历以及对周围使用 Java 的同事的观察，我总结了一些共通的问题以及相应的解决方法。如果你是一个 Java 新手（刚学会 Java 不久，工作1-2年），你可以看看我说的通病是不是你也有，如果有的话，得赶紧补救一下了！<br />&#12288;&#12288;接下来先说说第一个通病：<a href="../../2009/01/defect-of-java-beginner-1-algorithm.html">对算法和数据结构不熟悉</a>。<br /><br /><a name="index"> </a><br />为了方便阅读，把本系列帖子的目录整理如下（需翻墙）：<br />1. <a href="../../2009/01/defect-of-java-beginner-1-algorithm.html">对算法和数据结构不熟悉</a><br />2. <a href="../../2009/01/defect-of-java-beginner-2-oo.html">缺乏面向对象的基本功</a><br />3. <a href="../../2009/02/defect-of-java-beginner-3-code-style.html">缺少良好的编程习惯</a><br />4. <a href="../../2009/02/defect-of-java-beginner-4-exception.html">异常处理使用不当</a><br />5. <a href="../../2009/05/defect-of-java-beginner-5-jvm.html">对虚拟机（JVM）了解不足</a><br /><br /><br /><b>俺博客上，和本文相关的帖子（需翻墙）</b>：<br />《<a href="../../2012/05/weekly-share-5.html">每周转载：IT 大牛谈编程语言（网文3篇）</a>》<br />《<a href="../../2009/01/0.html">如何成为优秀开发人员</a>》（系列）<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/01/defect-of-java-beginner-0-overview.html">https://program-think.blogspot.com/2009/01/defect-of-java-beginner-0-overview.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/defect-of-java-beginner-1-algorithm.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>Java 新手的通病[1]：对算法和数据结构不熟悉 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">Java 新手的通病[1]：对算法和数据结构不熟悉</a></h1>
-<div class="post-info"><span class="date-header">2009-01-29</span><a href="../../tags/E7BC96E7A88B.html" class="tag">编程</a> <a href="../../tags/E7BC96E7A88B.Java.html" class="tag">编程.Java</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;为什么我先拿“数据结构和算法”说事捏？这玩意是写程序最最基本的东东。不管你使用 Java 还是其它的什么语言，都离不开它。而且这玩意是跨语言的，学好之后不管在哪门语言中都能用得上。<a name='more'></a><!--program-think--><br /><br />&#12288;&#12288;既然“数据结构和算法”这么重要，为什么很多 Java 新手却很不熟悉捏？我琢磨了一下，估计有两种可能。有些人虽然是计算机系毕业的，但是当初压根没好好学过这门课程，到工作时早都还给老师了；还有一些人是中途转行干编程，转行后又没有好好地打基础（都指望速成）。<br />&#12288;&#12288;下面我列出几个很基本的问题，如果你每一个问题都搞得很清楚，那说明你过了这关，可以去看看下一个帖子了。否则的话，你赶紧去找本算法和数据结构的书恶补一下吧。<br /><br />★什么时候该用数组型容器、什么时候该用链表型容器？<br />★什么是散列函数？HashMap 的实现原理是什么？<br />★什么是递归？如果你以前从来没写过递归函数，尝试着写一个（比如用递归函数进行目录树遍历）。<br />★什么是算法复杂度？<br />★你是否理解空间换时间的思想？<br />★写一个针对整数数组的冒泡排序函数，看看你要修改几次才能跑通。<br />★写一个针对整数数组的二分查找函数，看看你要修改几次才能跑通。<br /><br />&#12288;&#12288;后面接着说第2个通病：<a href="../../2009/01/defect-of-java-beginner-2-oo.html">缺乏面向对象的基本功</a>。<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/01/defect-of-java-beginner-1-algorithm.html">https://program-think.blogspot.com/2009/01/defect-of-java-beginner-1-algorithm.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/defect-of-java-beginner-2-oo.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>Java 新手的通病[2]：缺乏面向对象的基本功 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">Java 新手的通病[2]：缺乏面向对象的基本功</a></h1>
-<div class="post-info"><span class="date-header">2009-01-30</span><a href="../../tags/E7BC96E7A88B.html" class="tag">编程</a> <a href="../../tags/E7BC96E7A88B.Java.html" class="tag">编程.Java</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;按理说 Java 是一个很 OO 的语言，Java 社区也一向是充满了“对象”的氛围。但俺在面试 Java 程序员时，却屡屡碰到令人大跌眼镜的事情。俺碰到不止一个求职者，连什么是“多态”都讲不清楚。很多人号称用过设计模式，但一半以上都仅限于单键模式和抽象工厂模式。当我深入问他/她抽象工厂模式到底有什么好处时，很多人语焉不详。<a name='more'></a><!--program-think--><br /><br />&#12288;&#12288;为什么很多 Java 程序员会缺乏面向对象基本功？这得怪那些 Java 框架。现在 Java 的各种框架太发达、太傻瓜化了，导致很多程序员只需要按部就班、照着框架进行代码填空，基本已经丧失了 OOA 和 OOD 的能力。我手下有些个 Java 程序员，对 Spring、Hibernate 等框架了如指掌；但如果给他一个简单需求，让他写一个脱离 Web 框架的独立 Application，他就不知所措了。这样的开发人员，将来只能成为所谓的“软件蓝领”，岗位很难得到提升。<br /><br />&#12288;&#12288;同<a href="../../2009/01/defect-of-java-beginner-1-algorithm.html">上一个帖子</a>一样，我这次也提如下几个问题：<br />★基于接口的继承和基于实现的继承各有什么优缺点？<br />★继承（包括 extend 和 implement）有什么【缺点】？<br />★多态（polymorphism）有什么【缺点】？<br />★为什么 Java 可以多继承 interface，而不可以多继承 class？<br />★假如让你写一个小游戏（比如人机对战的五子棋），你会如何设计类结构？<br />★类结构设计时，如何考虑可扩展性？<br /><br />&#12288;&#12288;如果上述这些问题你都能够搞得比较清楚，说明你的 OO 基础还过得去。否则的话，我建议你一边找些 <a href="https://en.wikipedia.org/wiki/Object-oriented_analysis_and_design" target="_blank" rel="nofollow">OOAD</a> 和设计模式的书看看，同时自己动手写些简单的小程序（不依赖那些框架），把学到的模式理论结合到实践中。通过这种方式来提高自己 OOAD 的能力，效果会比较好。<br /><br />&#12288;&#12288;后面来聊一下第3个通病：<a href="../../2009/02/defect-of-java-beginner-3-code-style.html">缺少良好的编程习惯</a>。<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/01/defect-of-java-beginner-2-oo.html">https://program-think.blogspot.com/2009/01/defect-of-java-beginner-2-oo.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/job-in-economy-decline.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>白领如何应对经济危机，度过寒冬 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">白领如何应对经济危机，度过寒冬</a></h1>
-<div class="post-info"><span class="date-header">2009-01-23</span><a href="../../tags/E8818CE59CBAE782B9E6BBB4.html" class="tag">职场点滴</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;今天看到新闻说“<a href="http://news.xinhuanet.com/world/2009-01/23/content_10707226.htm" target="_blank" rel="nofollow">微软公司宣布裁员5000人</a>”。不由得感慨：连最牛的（微软手头现金最多）公司都不得不裁员了。去年（2008）爆发次贷危机，几大金融机构在去年（2008）9月倒台，距今也不过才4个月，金融危机已经波及到每一个行业（当然也包括 IT 业）——不禁让人想起“1929~1933”的那次萧条（那次号称是史上最强的）。面对这种情况，大伙该咋办捏？<br /><a name='more'></a><!--program-think--><br /><br /><h2>★1、分析自己公司的情况</h2><br />&#12288;&#12288;如果你是在大公司上班，公司倒闭的概率相对小一些。直接跳到第2条。如果你在中小型的公司，你得关心一下自己公司是否具有稳定的现金流（通俗地说就是：能否赚钱），并且这个现金流是否受经济危机影响。如果你的公司还没有开始盈利，你得关心一下萧条期之前公司是否已经拿到足够的风投（借用红杉资本某头头的说法——初创公司至少得储备够用2年的运营资金）。如果你公司既没有稳定的、不受影响的盈利模式，又没有足够的风险投资，那你得赶紧为跑路作准备了 :-(<br /><br /><br /><h2>★2、分析自己部门的情况</h2><br />&#12288;&#12288;在经济危机中，有些大、中型的公司喜欢【竖】着切（把差的部门砍掉）。因此你要多关注一下自己所在的部门是不是公司的核心部门（能够给公司带来现金流）。如果你的部门属于比较外围的、非盈利的，你就要小心自己所在的部门被一刀切掉。<br /><br /><br /><h2>★3、分析自己在公司的地位</h2><br />&#12288;&#12288;还有一些公司喜欢【横】着切（在每一个部门搞末位淘汰）。这时候你就得掂掂自己的分量了。看看自己在部门里面是否属于关键人物（离了你就不好办）。<br />&#12288;&#12288;如果你属于可有可无的小角色，那你从现在开始就要“小心做事、低调做人”，免得出了岔子被上司当作把柄。<br /><br /><br /><h2>★4、不要轻易跳槽</h2><br />&#12288;&#12288;在经济萧条的大环境下，跳槽一定要【非常谨慎】哦！如果你按照上述3条方法分析了之后，发现你目前的岗位还算稳定，那就老老实实呆着，不可轻举妄动。即使你分析下来，觉得目前的岗位不宜久留，也不要轻易跳槽。要先找好下家，并把下家分析一番（还是用上述3条分析方法）。除非分析之后觉得下家的岗位可靠性远大于你现在的岗位，否则不要主动提辞职信。<br />&#12288;&#12288;关于“跳槽”这个话题，还可以参考俺后来写的一篇博文：《<a href="../../2009/11/job-hopping.html">跳还是不跳，是一个问题——跳槽时该如何权衡？</a>》<br /><br /><br /><h2>★5、利用萧条期积累个人能力</h2><br />&#12288;&#12288;不过经济危机也不全是坏事（套用“<a href="../../2012/06/weekly-share-8.html">辩证法</a>”，凡事都有好坏两面哦）。在萧条期，很多人会比以前更空闲（例如公司的项目少了、公司的产品卖得差了）。这时候你最好能够抓住这个机会提高个人的水平，多学点【实用】技能。等到萧条期结束的时候，没准你学的东东正好可以派上用场。<br />&#12288;&#12288;如果你想要提升个人能力，可以参考如下博文：<br />《<a href="../../2013/09/knowledge-structure.html">如何完善自己的知识结构</a>》<br />《<a href="../../2013/04/how-to-read-book.html">＜如何阅读一本书＞——书评及内容纲要</a>》<br />《<a href="../../2009/02/study-technology-in-three-steps.html">学习技术的三部曲：WHAT、HOW、WHY</a>》<br /><br /><br /><h2>★6、改变理财和消费习惯</h2><br />&#12288;&#12288;如果你以前花钱大手大脚，喜欢超前消费，从现在开始就得彻底改掉。从2009年开始，国内通货紧缩的风险加大（和通胀相反，会导致商品跌价）。因此，在萧条期没结束前，尽量不要购买大宗商品，要坚持【现金为王】的观点不动摇。<br /><br /><br /><b>俺博客上，和本文相关的帖子（需翻墙）</b>：<br />《<a href="../../2019/12/Time-and-Life.html">时间与人生——跨入本世纪20年代的随想</a>》<br />《<a href="../../2013/09/knowledge-structure.html">如何完善自己的知识结构</a>》<br />《<a href="../../2013/04/how-to-read-book.html">＜如何阅读一本书＞——书评及内容纲要</a>》<br />《<a href="../../2009/11/job-hopping.html">跳还是不跳，是一个问题——跳槽时该如何权衡？</a>》<br />《<a href="../../2014/01/misunderstanding-about-making-money.html">为啥急功近利反而赚不到钱——给拜金主义者的忠告</a>》<br />《<a href="../../2018/06/weekly-share-121.html">每周转载：德鲁克谈【自我管理】——＜哈佛商业评论＞史上最受欢迎的文章</a>》<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/01/job-in-economy-decline.html">https://program-think.blogspot.com/2009/01/job-in-economy-decline.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/test.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>博客开张及本博客内容简介 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">博客开张及本博客内容简介</a></h1>
-<div class="post-info"><span class="date-header">2009-01-15</span><a href="../../tags/E58D9AE5AEA2E9809AE5918A.html" class="tag">博客通告</a> </div>
-<hr/>
-<div class="post">
-很久以前就想开一个博客，可惜一直忙于工作中，不能如愿。<br />拜2008年的全球金融危机所赐，我不再像以前那么忙碌，终于能够抽时间把以前的一些经验和平时的一些心得体会写下来。<br />希望这个博客能够让读者有所收获。<br /><br />初步考虑写如下一些方面的内容：<br />★对于开发人员的个人发展和成长的体会<br />主要介绍一些方法论相关的东东（比如：学习方法、思维方式、做事习惯等），毕竟“<b>授人以鱼不如授人以渔</b>”。<br />★关于 C++、Java、Python 语言<br />主要介绍和编程语言相关的开发经验。会比较侧重于开发跨平台，高性能、可扩展性方面的话题。<br />★关于软件工程<br />主要介绍软件工程相关的知识、项目管理的经验、复杂系统的架构设计等。<br />★关于管理<br />主要介绍企业管理相关的经验和职场心得。<br /><br />如果有空，我也会顺便八卦一下 IT 业界的新动态。<br /><br /><br /><b>俺博客上，和本文相关的帖子（需翻墙）</b>：<br />《<a href="../../2020/01/11-years-blogging.html">开博11周年庆，博文分类汇总</a>》<br />《<a href="../../2019/01/Memorabilia.html">开博十周年大事记</a>》<br />《<a href="../../2019/01/ten-years-blogging.html">开博十周年庆，博文分类汇总</a>》<br />《<a href="../../2018/01/nine-years-blogging.html">开博九周年庆，博文分类汇总</a>》<br />《<a href="../../2017/01/eight-years-blogging.html">开博八周年庆，博文分类汇总</a>》<br />《<a href="../../2016/01/seven-years-blogging.html">开博七周年庆，博文分类汇总</a>》<br />《<a href="../../2015/01/six-years-blogging.html">开博六周年庆，博文分类汇总</a>》<br />《<a href="../../2014/01/five-years-blogging.html">开博五周年总结，博文分类汇总</a>》<br />《<a href="../../2013/01/four-years-blogging.html">开博四周年总结，博文分类汇总</a>》<br />《<a href="../../2012/01/three-years-blogging.html">开博三周年总结，博文分类汇总</a>》<br />《<a href="../../2010/01/2009-review.html">开博周年庆，顺便总结一下</a>》<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/01/test.html">https://program-think.blogspot.com/2009/01/test.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/01/twitter-and-break-news-and-people.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>从 Twitter 的突发新闻报道看草根记者的崛起 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">从 Twitter 的突发新闻报道看草根记者的崛起</a></h1>
-<div class="post-info"><span class="date-header">2009-01-24</span><a href="../../tags/IT.html" class="tag">IT</a> <a href="../../tags/IT.E4B89AE7958CE8AF84E8AEBA.html" class="tag">IT.业界评论</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;在几天前的“纽约客机哈德森河成功迫降”事件中，<a href="https://twitter.com/" target="_blank" rel="nofollow">Twitter</a> 又一次拔得头筹（为什么说“又”捏？因为之前的孟买恐怖袭击，Twitter 已经抢先传统媒体了）。在率先到达出事地点的救生艇上，贾尼斯·克鲁姆斯同学（Janis Krums）用自己的 iPhone 手机拍摄了照片并上传到 Twitter，成为了飞机迫降后的首张现场照片。<a name='more'></a><!--program-think--><br /><center><img src="../../images/2009/01/zPDZQ4P1hlNM1Yo4ksRmMQglUMdQc9eoxEbi-gcPU57A9zByWI1ebwUXlmnmF9-2UtVtxrWmfF4tevEsByvaMm4C54YPuH5Ad3b84hO1drxO2m2E9-ph0TuZAJBLWF7KgSZP-xus" alt="不见图 请翻墙" /></center><br />&#12288;&#12288;最近已经有好几次突发事件是由 Twitter 抢先报道，草根记者大有后来居上的势头。这主要得益于可拍照、可上网手机的普及和 SNS（社会化网络）的流行，使得大伙儿都可以成为爆料的记者。这方面的优势，传统媒体是很难超越的（毕竟电视台、报社、杂志的人手有限）。从目前的发展趋势看，将来传统媒体的优势将被局限在报道的【全面性】和【深入性】等方面，而不得不放弃“实时性”的优势。<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/01/twitter-and-break-news-and-people.html">https://program-think.blogspot.com/2009/01/twitter-and-break-news-and-people.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/5.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>如何成为优秀开发人员[5]：正确地做事（概述） - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">如何成为优秀开发人员[5]：正确地做事（概述）</a></h1>
-<div class="post-info"><span class="date-header">2009-02-15</span><a href="../../tags/E8818CE59CBAE782B9E6BBB4.html" class="tag">职场点滴</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;从上一个帖子“<a href="../../2009/01/4.html">做正确的事</a>”写完到现在已经过去2周了，有网友已经等不及，在评论中催我了。在此向等待本系列的网友致歉。<br />&#12288;&#12288;和“<a href="../../2009/01/4.html">做正确的事</a>”相对应，“正确地做事”主要讨论的是有关工作【效率】和工作【质量】的关系（也就是如何“多、快、好、省”地完成工作）。由于"正确地做事"这个话题比较大，涉及到几个不同方面的【方法论】，考虑了很久，感觉一个帖子难以全部写完（俺不喜欢写长篇大论的帖子）。最后决定搞个【子系列】，针对每个方面写一个帖子。<a name='more'></a><!--program-think--><br />&#12288;&#12288;如果你是一个在校的学生或者刚入行的新手，这个“子系列”应该对你很有帮助；如果你是一个团队的小头目（Team Leader），你可以根据这个“子系列”来培训你手下的新员工。<br /><br />&#12288;&#12288;为了便于阅读，把和"正确地做事"有关的帖子目录列在下面：<br />1. <a href="../../2009/02/6.html">善用工具</a><br />2. <a href="../../2009/02/7.html">善用自动化</a><br />3. （未完待续）<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/02/5.html">https://program-think.blogspot.com/2009/02/5.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/6.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>如何成为优秀开发人员[6]：正确地做事（善用工具） - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">如何成为优秀开发人员[6]：正确地做事（善用工具）</a></h1>
-<div class="post-info"><span class="date-header">2009-02-15</span><a href="../../tags/E8818CE59CBAE782B9E6BBB4.html" class="tag">职场点滴</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;俗话说“工欲善其事，必先利其器”，今天我们来说说和开发工具有关的话题。由于开发过程中会用到的工具多种多样，根据“<a href="../../2009/02/80-20-principle-0-overview.html">二八原理</a>”，我只挑选和开发最密切相关的少数几种工具来聊一聊。<a name='more'></a><!--program-think--><br /><br /><a name="editor"> </a><br /><h2>★编辑器</h2><br />&#12288;&#12288;编辑器显然是用的最频繁的工具了（尤其是对于经常写代码的人），但是很大一部分人不善于使用编辑器。因此我先来说一下对编辑器使用的一些体会。顺便提一下，如果你连盲打都没过关，请先去学打字，再回来看这个帖子。<br /><br /><h3>◇字体</h3><br />&#12288;&#12288;对于写代码而言，字体的选择是非常重要的（看起来舒服的字体起码能保护眼睛）。首先必须选择一种【等宽】的字体（比如 FixedSys、Courier New）；其次该字体必须能够【清楚地区分】如下几种容易混淆的字符，避免阅读代码的时候看错：<br /><blockquote style="font-family:Courier,monospace;">数字0　和　字母O<br />数字1　和　大写字母I　和　小写字母l　和　或运算符|<br />数字2　和　字母z<br />数字9　和　小写字母q<br />乘号*　和　字母X<br />分号;　和　冒号:</blockquote><br /><h3>◇颜色</h3><br />&#12288;&#12288;你使用的编辑器必须支持【自定义】的词法高亮（词法着色）。<br />&#12288;&#12288;对词法高亮进行设置时，至少要把：“代码注释、关键字、字符串、数字”这几种语法要素用不同的颜色区分开。当然，如果还能根据“类名、函数名、变量名等”进行着色，那就更好了。<br /><br /><h3>◇快捷键</h3><br />&#12288;&#12288;熟练地使用快捷键能大大提高编辑的效率。因为你的手不需要离开键盘去操纵鼠标。而且当编辑的文本比较大时，有些编辑命令即使用鼠标操作也挺费劲（比如全选、移动到文件尾），不如快捷键方便。<br />&#12288;&#12288;所以，你使用的编辑器必须支持快捷键（这个大多数都能做到），而且还必须支持编辑命令和快捷键的<b>绑定</b>（也就是自己设置某个编辑命令对应的快捷键），便于根据个人喜好设置快捷键。<br /><br /><h3>◇其它功能</h3><br />还有一些比较琐碎的功能，比如：代码自动缩进、自动补全、动态提示等等。最后，如果你需要经常在不同的操作系统上进行工作，那你的编辑器还必须得支持跨平台才行。<br />虽然说了这么多条条框框，但是符合全部要求的软件并不难找，比如<a href="http://www.gnu.org/software/emacs/" target="_blank" rel="nofollow">Emacs</a>、<a href="http://www.vim.org/" target="_blank" rel="nofollow">VIM</a>、<a href="http://www.eclipse.org/" target="_blank" rel="nofollow">Eclipse</a>等软件都可以满足上述的编辑功能，具体选哪个就看各自的偏爱了。<br /><br /><a name="rcs"> </a><br /><h2>★源代码管理工具（版本管理软件）</h2><br />&#12288;&#12288;为了打字方便，以下简称“RCS”（Revision Control System）。<br />&#12288;&#12288;通过 RCS 的使用状况，可以看出一个开发团队在软件工程方面的成熟度，因此我们接下来要说说 RCS 的问题。如果你所在的开发团队从来不使用 RCS 进行代码的版本控制，那俺建议你赶紧考虑跳槽。<br />&#12288;&#12288;据俺多年的观察，发觉 RCS 主要有如下几种误用的情况：<br /><br /><h3>◇不正确的提交频度</h3><br />&#12288;&#12288;有很多新手不习惯使用 RCS，很少进行代码的提交。有些人甚至到项目快结束时还没有提交过一行代码。结果导致整个 RCS 形同虚设。<br />&#12288;&#12288;还有一些人则走向另一个极端，频繁提交代码。有些人每改完一个文件就提交一次，还有些人甚至把修改一半，尚【不能】编译通过的代码也提交到 RCS。<br />&#12288;&#12288;俺个人认为，正确的提交频度应该分两种情况：在编写功能代码时，每完成一个功能点，并且自己经过了自测之后，提交一次；在调试的时候，每修复一个 bug，提交一次。这样能够保证提交到 RCS 的代码都是【能编译通过】的（详见<a href="../../2009/02/daily-build-0-overview.html">每日构建系列</a>），并且业务逻辑上也是相对完整的（对于每日构建后的测试很重要）。<br /><br /><h3>◇提交时不写注释</h3><br />&#12288;&#12288;很多人提交代码时不写注释，将来再想到版本历史里面找代码就犹如大海捞针般困难。<br />&#12288;&#12288;比如在俺经手的代码中，有些源代码文件历时3年，提交次数上百次，如果提交时不写注释，日后根本没法找。<br /><br /><h3>◇不做代码基线（Baseline）、不做代码分支（Branch）</h3><br />&#12288;&#12288;在正规的开发团队，每当有一个版本发布（Release）并交付给用户使用时，都需要在 RCS 中制作一个基线，以便于进行相应的 bug 跟踪和补丁制作。因此，诸如【做基线】之类的事情，属于整个团队的集体行为，需要由 Team Leader 牵头来搞。<br />&#12288;&#12288;假如一个开发团队从来不做代码基线或者代码分支，仅仅是把 RCS 当成一个源文件的备份工具来用，那至少说明这个团队的 Team Leader 在软件工程管理方面非常失败。<br /><br /><a name="test"> </a><br /><h2>★用于调试/测试的运行辅助工具</h2><br />&#12288;&#12288;运行辅助工具对于开发效率的影响也很大。一般来说，你自己的开发机器上要有尽可能仿真（和用户的环境相似）的运行环境，并且运行辅助工具能够有效地发现运行时的一些不正常的信息。这样有利于让 bug 在交付给用户之前【尽早暴露】出来。<br />&#12288;&#12288;如果你是 Web 开发人员，那么你自己肯定要安装好常用的浏览器（至少包括 IE、Firefox、Chrome）。对于 IE，还得设置成“显示脚本错误通知”。<br />&#12288;&#12288;如果你主要开发 Windows 应用程序，你手头肯定要备好诸如：<a href="https://en.wikipedia.org/wiki/Dependency_walker" target="_blank" rel="nofollow">Depends</a>（Visual C++自带）、<a href="https://en.wikipedia.org/wiki/Process_Explorer" target="_blank" rel="nofollow">Process Explorer</a>等工具，便于查看进程、线程、动态库、堆内存等运行时信息。<br />&#12288;&#12288;如果你是搞手机应用的，那么你至少得有目标系统的模拟器软件（如果能配一个真机当然更好）。<br />&#12288;&#12288;如果你主要进行跨平台方面的开发，那么诸如“<a href="https://en.wikipedia.org/wiki/VMware" target="_blank" rel="nofollow">VMware</a> / <a href="https://en.wikipedia.org/wiki/VirtualBox" target="_blank" rel="nofollow">VirtualBox</a>”之类的虚拟化软件是必不可少滴（关于这类软件，俺写过一个系列：《<a href="../../2012/10/system-vm-0.html">扫盲操作系统虚拟机</a>》）<br />......<br /><br />&#12288;&#12288;限于篇幅，今天就只说这些。其它我未提及的工具，大伙儿自己可以举一反三。下一个话题，打算说说“<a href="../../2009/02/7.html">善用自动化</a>”。<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/02/6.html">https://program-think.blogspot.com/2009/02/6.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/7.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>如何成为优秀开发人员[7]：正确地做事（善用自动化） - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">如何成为优秀开发人员[7]：正确地做事（善用自动化）</a></h1>
-<div class="post-info"><span class="date-header">2009-02-24</span><a href="../../tags/E8818CE59CBAE782B9E6BBB4.html" class="tag">职场点滴</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;<a href="../../2009/02/6.html">上一个帖子</a>聊了“善用工具”的话题，讲的都是如何有效利用工具来提高效率，今天说一下如何利用“自动化”来提高效率。<a name='more'></a><!--program-think--><br /><br /><br /><h2>★“自动化”的重要性</h2><br />&#12288;&#12288;隐约记得 Perl 语言的创始人<a href="https://en.wikipedia.org/wiki/Larry_Wall" target="_blank" rel="nofollow">Larry Wall</a> 曾经评价过程序员的三大美德，分别是：【懒惰、急躁、傲慢】。（刚才找到原文在<a href="https://en.wikipedia.org/wiki/Larry_Wall#Virtues_of_a_programmer" target="_blank" rel="nofollow">这里</a>）在这三大美德中，“懒惰”赫然排在第一，可见其重要（另外，马云似乎也说过类似的名言）。<br />&#12288;&#12288;俺对他所说的“懒惰”是这样理解的——就是干尽量少的活，但是依然保质保量地完成工作。那么，如何才能偷懒捏？一个有效的办法就是【自动化】。<br />&#12288;&#12288;俺这里说的“自动化”，当然不是大学里自动化专业的那个“自动化”，而是指：利用各种方式（主要是计算机）来帮你【自动完成】某些（枯燥、费时、无价值）的重复劳动；然后你就可以利用节省出来的时间，干一些更有意义的事情了（比如学习点有用的东西）。<br />&#12288;&#12288;具体该如何做呢？要实现自动化，首先就要观察你平时做的事情中，有哪些属于【重复】劳动；然后评估一下这些重复劳动是否可以用某些工具来替代；如果有可能替代，你就可以动手把这个工具实现出来，然后就可以让工具来帮你做事情了。<br />&#12288;&#12288;说了这么多，感觉有些抽象，下面我举几个方面的例子来给大伙儿加深一下印象。<br /><br /><br /><h2>★实现“自动化”的例子</h2><a name="blog"> </a><br /><h3>◇Blog 订阅</h3><br />&#12288;&#12288;如果你经常看俺的 Blog，但是没有使用 Feed（RSS） 订阅工具，那你就要当心了。你属于不善于利用自动化的人。<br />&#12288;&#12288;使用了 Feed 订阅工具，你就不需要经常访问某个 URL 的页面去看有没有新帖子。因为这个枯燥的重复劳动已经由订阅工具帮你【自动完成】了。你所要做的，仅仅是在订阅工具中初始化某个 URL（只要做一次），然后订阅工具会在有新帖子的时候通知你。所以，除非你要发评论，否则不需要访问俺博客的页面 :-)<br /><a name="debug"> </a><br /><h3>◇调试程序</h3><br />&#12288;&#12288;估计看俺 Blog 的同学，大部分都有过调试程序的经验。当程序行为不正常时，经常需要设置断点，然后单步跟踪代码，以便找出程序出错的源头。其实这个过程也有大量的重复劳动。<br />&#12288;&#12288;俺一般喜欢通过程序断言（以下简称 assert）来简化上述过程。看到这里，有些同学心里犯嘀咕了：程序断言和自动化有毛关系啊？其实每一个 assert 就好比一个【自动的】代码检查点，【每次】程序运行到 assert 处的时候，如果你设置的逻辑条件不成立，它会立即终止程序并打印出相关信息（比如函数调用栈、文件行号等）。<br />&#12288;&#12288;如果你在写代码的时候，经常在一些【关键点】设置一些【条件恰当】的 assert，可以大量节约调试时间。俺自己写的程序，在自测的时候，有70%-80%的逻辑错误会被 assert 暴露出来，所以改起来非常快；测试人员提交给俺的 Bug，大概也有一半以上可以通过 assert 快速定位出错误的源头。<br /><a name="test"> </a><br /><h3>◇自动化测试</h3><br />&#12288;&#12288;说完了程序员的例子，再来说一下测试人员（其实我在“<a href="../../2009/02/daily-build-3-proces.html">每日构建：流程</a>”已经稍微提到了测试的自动化）。俺发现很多公司的测试人员，重复劳动特别严重。他们不断地重复做一些软件功能的验证操作；发现bug后通知程序员改；程序员改完，再次进行���证操作......如此循环往复。N年之后，这些测试人员的个人能力没啥提高，年龄倒大了不少。<br />&#12288;&#12288;在此，俺强烈建议测试人员：尽量多使用一些自动化测试工具（比如 <a href="https://en.wikipedia.org/wiki/HP_QuickTest_Professional" target="_blank" rel="nofollow">QTP</a>）和一些测试脚本来完成上述的软件功能验证操作。不光能节约很多时间，提高了效率；而且在自己编写测试脚本的过程中，或许还能学些新东西，提高一下个人能力。比如俺见过一个测试人员，由于经常用<a href="https://www.python.org/" target="_blank" rel="nofollow">Python</a>写一些脚本进行网络和数据库方面的测试，久而久之，写 Python 脚本的水平很熟练，然后就被转去做 Python 开发。<br /><br /><a name="human"> </a><br /><h2>★人肉自动化</h2>&#12288;&#12288;上面说的自动化都是技术层面的（都是靠软件实现）。为了给大伙儿扩展一下思路（免得思维定势），最后来说一下非技术的例子。<br />&#12288;&#12288;比如部门中经常有人出差，每次出差都要都要订机票。订机票就属于重复劳动，而且挺繁琐。得去网上查航班、还得看哪个航班折扣优惠、选好航班还得付钱，然后去机场还得打印行程单，出差回来还得填写报销单（报销单还得找N个人签字），然后拿着报销单与行程单找秘书报销。这些琐事累加起来，少说也得一个小时才能搞好。<br />&#12288;&#12288;为了提高效率，把上述这些琐事统统都交由秘书搞定。出差的家伙需要做的就是发一个邮件告诉秘书，要订某天某时的飞机到某地，就一切 OK 了。经过这样改革，部门里的人（除了秘书）都皆大欢喜。<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/02/7.html">https://program-think.blogspot.com/2009/02/7.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/80-20-principle-0-overview.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>无处不在的二八原理[0]：什么是二八原理 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">无处不在的二八原理[0]：什么是二八原理</a></h1>
-<div class="post-info"><span class="date-header">2009-02-09</span><a href="../../tags/E7AEA1E79086.html" class="tag">管理</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;估计看俺博客的人里面，应该有很多人听说过二八原理（如果你之前从来没听说过，那你的知识面有太窄的嫌疑）。但是知道二八原理的人有很多却不会（或者不善于）运用。直接的后果就是你在各种事情上付出了很多时间与精力，但是回报却很少。鉴于该原理非常非常的实用，俺打算专门写一个系列来聊聊和它相关的话题。<a name='more'></a><!--program-think--><br /><br /><br /><h2>★什么是二八原理</h2><br />&#12288;&#12288;按照惯例，先说说什么是二八原理（如果你已经知道二八原理，可以跳过这部分）。二八原理（也称为“80/20原理”或“帕雷托原理”）最早是由意大利的经济学家帕雷托提出来的，关于这个原理的详细介绍请看“<a href="https://en.wikipedia.org/wiki/Pareto_principle" target="_blank" rel="nofollow">这里</a>”。通俗地说，就是【因果的不对称】。20% 的原因导致了 80% 的结果；而其它 80% 的原因只产生 20% 的结果。当然，这里提到的“二八开”的比例不是绝对的，从“三七开”到“一九开”都有可能。<br />&#12288;&#12288;为了给不了解它的人一点感性认识，俺举几个例子：<br /><blockquote>少数有钱人掌握了社会的大部分财富（帕雷托就是从财富分布中发现该原理的）<br />公司里大部分的销售业绩由小部分的销售人员创造<br />地毯的大部分磨损集中在少数几个地方<br />大部分开发人员只使用少数的编程语言，而大量的编程语言几乎没人用<br />软件的大部分 bug 是由少数开发人员产生的</blockquote><br /><br /><h2>★如何运用</h2><br />&#12288;&#12288;首先，这个原理的关键处就在于它挑战了传统的理念。比如：小时候老师经常教导说：“一分付出一分回报”。用数学的术语讲，就是付出和回报是呈线性相关的。很多人受此影响（可能是潜意识的影响），都习惯于平均分配时间、精力来处理问题。结果就导致我前面所说的投入很多，回报很少。因此，要运用二八原理之前，你先得改变自己头脑中的思维定势，要以【<b>不平等</b>】的观点来看周围的问题。（关于改变思维定势，关键还是靠自己，俺帮不上太大忙）<br />&#12288;&#12288;其次，你得学会如何区分重要与次要。这个就属于方法论的问题。俺之前写过几个帖子都和这方面有关，比如：《<a href="../../2009/01/choose-it-book.html">如何选择 IT 技术书籍</a>》和《<a href="../../2009/01/4.html">做正确的事</a>》，以后还会继续写相关的帖子，希望对大伙儿能有帮助。<br /><br /><a name="index"> </a><br />为了方便阅读，把本系列帖子的目录整理如下（需翻墙）：<br />1. <a href="../../2009/02/80-20-principle-1-software-developing.html">在软件开发中的运用</a><br />2. <a href="../../2009/03/80-20-principle-2-management-overview.html">在管理方面的运用（概述）</a><br />3. <a href="../../2009/03/80-20-principle-3-management-hire.html">在管理方面的运用（如何找到优秀的开发人才）</a><br />4. <a href="../../2009/03/80-20-principle-4-management-encourage.html">在管理方面的运用（如何激励员工）</a><br />5. （未完待续）<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/02/80-20-principle-0-overview.html">https://program-think.blogspot.com/2009/02/80-20-principle-0-overview.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/80-20-principle-1-software-developing.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>无处不在的二八原理[1]：在软件开发中的应用 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">无处不在的二八原理[1]：在软件开发中的应用</a></h1>
-<div class="post-info"><span class="date-header">2009-02-10</span><a href="../../tags/E7AEA1E79086.html" class="tag">管理</a> <a href="../../tags/E7BC96E7A88B.html" class="tag">编程</a> <a href="../../tags/E7BC96E7A88B.E8BDAFE4BBB6E5B7A5E7A88B.html" class="tag">编程.软件工程</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;上次聊了《<a href="../../2009/02/80-20-principle-0-overview.html">什么是二八原理</a>》，接下来得说说如何运用了。由于本博客主要谈 IT 技术，显然要先来说说和程序员有关的那些事。为了不至于太抽象，咱们以“开发文本编辑器”为例（这玩意大伙儿都熟悉，省得费口水解释），来说说不同职责的开发人员在开发过程中该如何具体运用二八原理。<a name='more'></a><!--program-think--><br /><br /><br /><h2>★需求分析</h2><br />&#12288;&#12288;需求分析在整个开发过程中占的工作量不大，但是产生的影响巨大（这又是一个二八原理的例子）。既然需求分析如此重要，照理说应该安排最强的人来搞。但实际情况往往不是如此：很多公司负责需求分析的人并不胜任这项工作。俺经历过几个不太成功的项目，其问题的根源都和需求分析有关。<br />&#12288;&#12288;需求分析最要紧的是：搞清楚用户【到底】想要什么？如果这个问题搞错了、搞偏了，后面的步骤做得再好也是白搭（比如客户想要一个文本编辑器，结果你搞了个图形编辑器给他）。这方面其实有很多的道道，限于篇幅就不展开了，大伙儿如果有兴趣，以后可以单独说一下。<br />&#12288;&#12288;在搞清楚“用户想要什么”之后，接着要整理出功能列表（洋文叫“Feature List”），并筛选出大约20%的重点功能。这个步骤是俺今天想重点聊的，因为这个步骤和后续的各项开发密切相关。一般来说，功能筛选的依据有如下几个：<br />1、用户经常用的功能（比如：save、copy、cut、paste）<br />2、宣传的卖点（要能够超出同类软件，吸引眼球）<br />3、和用户利益密切相关的功能（这种功能不允许出错，比如存盘功能）<br />&#12288;&#12288;这个筛选的过程要尽早完成，而且最好是产品人员、开发人员、测试人员三方的头头一起讨论，以保证立场客观、观点全面。筛选出重要功能点后，其他人员的工作安排要"以重点功能为纲"，有所侧重。<br /><br /><br /><h2>★项目管理</h2><br />&#12288;&#12288;如果你是个项目经理，在排项目计划时，就得尽量优先安排【重点功能】的开发/测试，而且要安排能力强的人员来完成。照俺以前的做法，重点功能排计划至少得留出1/3的时间余量，以防万一（事实证明，几乎每个稍大点的项目都会出现【万一】）。至于【非】重点功能，尽量排到后面，安排能力一般的人开发/测试。<br />&#12288;&#12288;然后，在项目进行过程中，肯定要有定期的例会。作为项目经理，你应该主要关注重点功能的进度情况和风险情况。<br />&#12288;&#12288;一旦项目有延期的风险，就从非重点功能开始裁减（俗称砍功能）。由于是裁减<b>非</b>重点功能，不至于产生致命的影响。<br /><br /><br /><h2>★设计界面</h2><br />&#12288;&#12288;设计界面时，你得保证【所有的】常用功能都放在显著的位置（比如工具条）；还得保证它们用起来方便（比如提供快捷键和右键菜单支持）。<br />&#12288;&#12288;对于卖点，它不一定是常用功能，它的目的是激起用户的购买欲望和使用欲望。因此你要把它们设计得比较酷，有噱头。<br />&#12288;&#12288;对于利益相关的功能，大部分情况下都是侧重于业务逻辑实现。如果它既不是常用功能、也不是卖点，那么界面设计方面倒不一定要额外花大力气。<br />&#12288;&#12288;其它的【非】重点功能，只要按照常规方法设计，不用花太大精力。<br /><br /><br /><h2>★编写代码</h2><br />&#12288;&#12288;俺发现很多开发人员有几个通病：先做有趣或容易的功能，然后再做无聊或者繁琐的功能；对自己有兴趣的功能投入精力多，对自己没兴趣的简单应付。<br />&#12288;&#12288;以上这些都是开发的大忌。作为一个职业的开发人员，不应该以自己的兴趣和喜好来决定开发的轻重缓急。正确做法应该如下：<br />&#12288;&#12288;你首先得用主要精力完成上述所说的重点功能，而且要保证它们的代码质量尽可能好，尽可能方便维护（重点功能往往是经常有需求变更，经常被修改的）。<br />&#12288;&#12288;对于重点功能中的【常用功能】，要保证“时间性能够好”（通俗地说，就是快速响应）。对于【用户利益相关的功能】，要保证 bug 尽可能少（尤其是安全性、稳定性、健壮性的 bug）。<br />&#12288;&#12288;至于其它的【非】重点功能，只要不出明显 bug，有点小缺陷无伤大雅。<br /><br /><br /><h2>★测试</h2><br />&#12288;&#12288;如果你是个测试人员，你同样要把主要精力用于测试那些重点功能。对于"用户利益相关的功能"，多进行一些健壮性测试、稳定性、安全性等测试（比如测试保存大文件是否会出错）。对于常用功能，主要进行易用性和性能测试（比如拷贝、粘贴是否易用）。<br />&#12288;&#12288;至于其它功能，只要进行普通的测试，保证它不出现明显和严重 bug 即可。要知道当年微软发布 Windows 2000 的时候，尚遗留上千个未修复的 bug（当然都是低优先级的），人家不也照样发布嘛。<br /><br /><br /><h2>★产品演示</h2><br />&#12288;&#12288;有些软件开发完之后，会搞一些 Demo 进行宣传。如果你是负责进行 Demo 的人，一定要把主要的 Demo 时间用来秀软件的卖点，这样给客户的印象最深刻，效果最好；至于【非】卖点的功能，甚至都不用提及。<br /><br /><br />&#12288;&#12288;几种和开发相关工作就介绍到这里，最后送给大伙一句话：【<b>Work Smart, Not Hard!</b>】<br />&#12288;&#12288;下一个帖子打算聊一下<a href="../../2009/03/80-20-principle-2-management-overview.html">二八原理在管理中的应用</a>。<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/02/80-20-principle-1-software-developing.html">https://program-think.blogspot.com/2009/02/80-20-principle-1-software-developing.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/cxx-cross-platform-develop-5-os.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>C++ 的可移植性和跨平台开发[5]：操作系统 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">C++ 的可移植性和跨平台开发[5]：操作系统</a></h1>
-<div class="post-info"><span class="date-header">2009-02-07</span><a href="../../tags/E7BC96E7A88B.html" class="tag">编程</a> <a href="../../tags/E7BC96E7A88B.C.html" class="tag">编程.C</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;上一个帖子提到了“<a href="../../2009/01/cxx-cross-platform-develop-4-hardware.html">硬件体系</a>”相关的话题，今天来说说和操作系统相关的话题。<a name='more'></a><!--program-think--><br />&#12288;&#12288;为了打字省力，以下把 Linux 和各种 Unix 都统称为 <a href="https://en.wikipedia.org/wiki/Posix" target="_blank" rel="nofollow">Posix</a> 系统。<br /><br /><br /><h2>★文件系统（以下把 FileSystem 简称为 FS）</h2><br />&#12288;&#12288;刚开始搞跨平台开发的新手，多半都会碰上和 FS 相关的问题。所以先来聊一下 FS。<br />&#12288;&#12288;归纳下来，开发中容易碰上的 FS 差异主要有如下几个：目录分隔符的差异；大小写敏感的差异；路径中禁用字符的差异。<br />&#12288;&#12288;为了应对上述差异，你要注意如下几点：<br /><br /><h3>◇文件和目录命名要规范</h3><br />&#12288;&#12288;在给文件和目录命名时，尽量只使用字母和数字。<br />&#12288;&#12288;不要在【同一目录】下放两个【只有大小写不同】的文件（例如 foo.cpp 与 Foo.cpp）。<br />&#12288;&#12288;不要使用某些 OS 的保留字（例如 aux、con、nul、prn）作文件名或目录名。<br />&#12288;&#12288;提醒一下：<br />&#12288;&#12288;刚才说的命名，包括了源代码文件、二进制文件和运行时创建的其它文件。<br /><br /><h3>◇#include 语句要规范</h3><br />&#12288;&#12288;当你写 <b>#include</b> 语句时，要使用正斜线“/”（各平台通用）而【不要】使用反斜线“\”（仅在 Windows 家族可用）。<b>#include</b> 语句中的文件和目录名要和实际名称保持大小写【完全一致】。<br /><br /><h3>◇代码中涉及FS操作，尽量使用现成的库</h3><br />&#12288;&#12288;已经有很多成熟的、用于 FS 的第三方库（比如 <a href="http://www.boost.org/libs/filesystem/" target="_blank" rel="nofollow">boost::filesystem</a>）。如果你的代码涉及到 FS 的操作（比如目录遍历），尽量使用这些第三方库，可以帮你省不少事情。<br /><br /><br /><h2>★文本文件的 回车（CR）与 换行（LF）</h2><br />&#12288;&#12288;由于几个知名的操作系统对回车/换行的处理不一致，导致了这个很烦人的问题。<br />&#12288;&#12288;目前的局面是：Windows 同时使用 CR 和 LF；Linux 和大部分的 Unix 使用 LF；苹果的 Mac OS 系列使用 CR。<br />&#12288;&#12288;对于源代码管理，好在很多版本管理软件（比如 CVS、SVN、Git）都会智能地处理这个问题，让你从代码库取回本地的源码能适应本地的格式。<br />&#12288;&#12288;如果你的程序需要在运行时处理文本文件，要留意本文方式打开和二进制方式打开的区别。另外，如果涉及跨不同系统传输文本文件，要考虑进行适当的处理。<br /><br /><br /><h2>★文件搜索路径（包括搜索可执行文件和动态库）</h2><br />&#12288;&#12288;在 Windows 下，如果要执行文件或者加载动态库，一般会搜索当前目录；而 Posix 系统则不尽然。<br />&#12288;&#12288;所以，如果你的应用涉及到启动进程或加载动态库，就要小心这个差异。<br /><br /><br /><h2>★环境变量</h2><br />&#12288;&#12288;对于上述提到的搜索路径问题，有些同学想通过修改 PATH 和 LD_LIBRARY_PATH 来引入当前路径。<br />&#12288;&#12288;如果要使用这种方法，建议你只修改进程级的环境变量，不要修改系统级的环境变量（修改系统级有可能影响到同机的其它软件，产生副作用）。<br /><br /><br /><h2>★动态库</h2><br /><h3>◇动态库导出函数</h3><br />&#12288;&#12288;如果你的应用程序使用动态库，强烈建议动态库导出标准 C 风格的函数；尽量不要导出类，也不要导出涉及名称重载的函数。<br /><br /><h3>◇符号表</h3><br />&#12288;&#12288;如果在 Posix 系统中加载动态库，切记慎用 <b>RTLD_GLOBAL</b> 这个标志位。<br />&#12288;&#12288;这个标志位会 Enable 全局符号表，有可能会导致多个动态库之间的��号名冲突（一旦碰到这种事，会出现匪夷所思的运行时错误，极难调试）。<br />&#12288;&#12288;关于动态库的话题比较大，限于篇幅，以后有时间再单独写一个帖子讨论。<br /><br /><br /><h2>★服务/看守进程</h2><br />&#12288;&#12288;如果你不清楚服务和看守进程的概念，请看维基百科（<a href="https://en.wikipedia.org/wiki/Windows_service" target="_blank" rel="nofollow">这里</a>和<a href="https://en.wikipedia.org/wiki/Daemon_%28computer_software%29" target="_blank" rel="nofollow">这里</a>）。（为了叙述方便，以下统称服务）<br />&#12288;&#12288;由于 C++ 开发的模块大部分是后台模块，经常会碰到服务的问题。编写服务需要调用好几个系统相关的 API，导致了与操作系统的紧密耦合，很难用一套代码搞定。<br />&#12288;&#12288;因此，比较好的办法是抽象出一个通用的服务外壳，然后把业务逻辑代码作为动态库挂载到它下面。这样的话，至少保证了业务逻辑的代码只需要一套；服务外壳的代码虽然需要两套代码（一个用于 Windows、一个用于 Posix），但他们是业务无关的，可以很方便地重用。<br /><br /><br /><h2>★默认栈大小</h2><br />&#12288;&#12288;不同的操作系统，“栈的默认大小”差别很大，从几十 KB（据说 Symbian 只有12K，真抠门）到几 MB 不等。<br />&#12288;&#12288;因此，你事先要打听一下目标系统的默认栈大小，如果碰上像 Symbian 这样抠门的，可以考虑用编译器选项调大。当然，养成“<b>不在栈上定义大数组/大对象</b>”的好习惯也很重要，否则再大的栈也会被撑爆的。<br /><br /><br />&#12288;&#12288;看到这里，可能有同学要问了，为什么没聊进程管理和多线程的话题？欲知后事如何，且听<a href="../../2009/04/cxx-cross-platform-develop-6-thread.html">下回分解</a>。<br /><br /><br /><a href="../../2009/01/cxx-cross-platform-develop-0-overview.html#index">回到本系列的目录</a><div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/02/cxx-cross-platform-develop-5-os.html">https://program-think.blogspot.com/2009/02/cxx-cross-platform-develop-5-os.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/cxx-object-destroy-overview.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>C++ 对象是怎么死的？为什么要写这个系列？ - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">C++ 对象是怎么死的？为什么要写这个系列？</a></h1>
-<div class="post-info"><span class="date-header">2009-02-26</span><a href="../../tags/E7BC96E7A88B.html" class="tag">编程</a> <a href="../../tags/E7BC96E7A88B.C.html" class="tag">编程.C</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;要说 C++ 对象是怎么死的，得先从 C++ 的析构函数说起。这玩意儿是我本人很喜欢的一个语言特性（可惜有好几个语言没有类似的玩意儿，具体就不点名了，免得引发口水战）。我们可以利用 C++ 的构造和析构函数，来实现 Guard 模式，写出比较清晰、简练和异常安全的代码。由于 Guard 模式在 C++ 程序中运用挺多，所以保证【<b>所有对象被析构</b>】就是一个很重要很严肃的问题。<a name='more'></a><!--program-think--><br />&#12288;&#12288;另外，我发现很多 C++ 程序员只关心内存泄露问题，不关心（或不清楚）资源泄露问题（很类似于我在“<a href="../../2009/02/defect-of-java-beginner-3-code-style.html#gc">Java新手通病[3]</a>”提到的现象）。比如昨天的《<a href="../../2009/02/cxx-object-destroy-with-process.html" target="_blank">C++对象是怎么死的？进程篇</a>》发布后，就有同学问了：进程死都死了，对象没销毁又有什么关系捏？其实大有关系啊！虽然操作系统会在进程死后帮它收尸（也就是把某些资源，比如内存进行回收），基本不用担心内存泄露的问题。但是别忘了，除了内存资源，进程中可能还包含有其它业务层面的资源，而这些资源，操作系统是不会帮你自动回收的。所以我要再啰嗦一次：【<b>资源泄露往往比内存泄露要严重得多啊</b>】。啰嗦完之后，为了加深印象，再举如下一个例子。<br />&#12288;&#12288;比如某业务逻辑 Foo 需要操作大量的临时文件（放在某动态生成的临时目录中），为了保证该业务逻辑结束后（可能是正常结束，也可能中途抛出异常），该临时目录总是被删除，可以使用如下的 Guard 模式。<br /><div class="source"><pre><span></span><span class="k">class</span> <span class="nc">CTempDirGuard</span><br /><span class="p">{</span><br /><span class="k">public</span><span class="o">:</span><br />    <span class="n">CTempDirGuard</span><span class="p">(</span><span class="k">const</span> <span class="n">string</span><span class="o">&amp;</span> <span class="n">sFolderName</span><span class="p">)</span><br />    <span class="p">{</span><br />        <span class="c1">// 创建某临时目录</span><br />    <span class="p">}</span><br /><br />    <span class="k">virtual</span> <span class="o">~</span><span class="n">CTempDirGuard</span><span class="p">()</span><br />    <span class="p">{</span><br />        <span class="c1">// 把该临时目录整个儿删除</span><br />    <span class="p">}</span><br /><span class="p">};</span><br /><br /><span class="kt">void</span> <span class="nf">Foo</span><span class="p">()</span><br /><span class="p">{</span><br />    <span class="n">CTempDirGuard</span> <span class="n">guard</span><span class="p">(</span><span class="n">xxx</span><span class="p">);</span>  <span class="c1">// 声明guard对象</span><br />    <span class="c1">// 往临时目录放东西</span><br />    <span class="c1">// 不管是出现 return 语句还是有异常抛出，guard 都会被析构，因而该 xxx 目录会被删除</span><br /><br />    <span class="c1">// 但是如果程序执行到此处，却发生进程的非自然死亡，</span><br />    <span class="c1">// 在这种情况下，该 guard 对象将【不会】被析构——因此会留下一个垃圾目录，浪费了硬盘资源</span><br /><span class="p">}</span><br /></pre></div><br />&#12288;&#12288;鉴于上述所说的两个原因，所以我一直想写一个这方面的帖子。正好前几天写了帖子讨论“<a href="../../2009/02/multi-process-vs-multi-thread.html">架构设计的多进程问题</a>”，之后就就顺便写了一个帖子：《C++ 进程是怎么死的？》，讨论了一下由于进程不同的死法对C++对象析构的影响。等写完之后突然想到：除了进程终止的问题可能导致 C++ 对象的【不】正常析构，还有线程等其它因素也可能会让 C++ 对象【不】正常析构。所以干脆就改了个名，叫《C++ 对象是怎么死的？》 :-)<br /><a name="index"> </a><br />另外，为了方便阅读，把本系列帖子的目录整理如下：<br />1、<a href="../../2009/02/cxx-object-destroy-with-process.html">进程篇</a><br />2、<a href="../../2009/02/cxx-object-destroy-with-io-stream.html">对标准输入输出流的进一步探讨</a><br />3、<a href="../../2009/03/cxx-object-destroy-with-thread-win32.html">Win32 线程篇</a><br />4、<a href="../../2009/03/cxx-object-destroy-with-thread-posix.html">POSIX 线程篇（pthread）</a><br /><br /><br /><b>俺博客上，和本文相关的帖子（需翻墙）</b>：<br />《<a href="../../2012/05/weekly-share-5.html">每周转载：IT 大牛谈编程语言（网文3篇）</a>》<br />《<a href="../../2009/01/0.html">如何成为优秀开发人员</a>》（系列）<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/02/cxx-object-destroy-overview.html">https://program-think.blogspot.com/2009/02/cxx-object-destroy-overview.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/cxx-object-destroy-with-io-stream.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>C++ 对象是怎么死的？关于标准输入输出流（cout,cerr,clog,etc）的进一步探讨 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">C++ 对象是怎么死的？关于标准输入输出流（cout,cerr,clog,etc）的进一步探讨</a></h1>
-<div class="post-info"><span class="date-header">2009-02-26</span><a href="../../tags/E7BC96E7A88B.html" class="tag">编程</a> <a href="../../tags/E7BC96E7A88B.C.html" class="tag">编程.C</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;昨天的帖子《<a href="../../2009/02/cxx-object-destroy-with-process.html">C++ 对象是怎么死的？进程篇</a>》，在谈到全局对象的析构顺序史，举了一个“在析构函数中使用 cout”的例子（代码详见<a href="../../2009/02/cxx-object-destroy-with-process.html">原文</a>）。当时的本意是想说明：全局对象的析构顺序是不确定的，最好不要在程序逻辑中依赖这个顺序（免得出现移植问题）。<br />&#12288;&#12288;没成想该帖子引来热烈的评论（俺有点受宠若惊了），关注的焦点主要集中在：“cout 是否会最后析构”。有些网友质疑我所提到的有关 VC6 的行为；有网友引用了《TCPPPL》上的相关章节（21.5.2）来说明“cout 会最先构造、最后析构”。既然大伙儿对标准流类库的构造和析构挺有兴趣，咱们今天就针对这个话题补充说明一下。<a name='more'></a><!--program-think--><br /><br /><h2>★标准都说了些啥？</h2><br />&#12288;&#12288;C++ 03 标准（18.3章节）提到了进程启动和终止。其中对进程的自然死亡有比较具体的描述，包括：各种类型的对象啥时候销毁、用 atexit 注册的退出函数啥时候被调用、还有输入输出流啥时候 flush 和 close 等等。<br />&#12288;&#12288;另外，在标准的 27.4.2.1.6章节 阐述了 ios_base::Init 如何通过包含一个引用计数，对八个标准流类库的全局对象进行适当的初始化和销毁。<br />&#12288;&#12288;那么，有了 C++ 03 标准作书面担保，咱们是否就高枕无忧捏？请看俺下面的分析：<br /><br /><h2>★关于老式编译器（03年之前推出）</h2><br />&#12288;&#12288;首先，某些老式编译器在标准发布之前推向市场，因此它们对标准的实现不够好（这不是废话嘛）。关于老式编译器的标准兼容性，在《<a href="../../2009/01/cxx-cross-platform-develop-2-language.html">C++ 移植性和跨平台开发[2]：语法</a>》有进一步说明。<br />&#12288;&#12288;说到“老式编译器”，最典型代表当然就是那个（让人又爱又恨的） VC++ 6.0 啦。其实已经有很多人碰到了“VC6 环境中 cout 提前析构”的问题，不信大伙儿可以在 Google 上搜一下。另外，如果你手头上正好有 VC6，可以试试附在本文末尾的“示例1”的代码，看是否能够正常打印，就知道了。<br />&#12288;&#12288;当然啦，VC6 可以称得上是古董级的编译器了，从1998年推出到现在，已经超过10个年头。所以它对标准的实现不好也无可厚非。<br /><br /><h2>★关于新式编译器（03年之后推出）</h2><br />&#12288;&#12288;刚才批了一通“老式编译器”，那么“新式编译器”是否就完美地支持 C++ 03 标准呢？俺感觉有点玄。所以今天特地试验了手头能找到的几个 C++ 编译器。看看它们是否能够保证 cout 最先构造、最后析构。另外，为了给这些新式编译器增加点挑战，俺把本文附带的“示例1代码”稍微修改了一下，变成“示例2代码”（说实话，这么写代码确实有点夸张），也附在本文末尾。<br />&#12288;&#12288;手头的几种编译器测试下来，结果如下：<br />－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－<br />｜操作系统　　　　｜　编译器类型　　　　　　　｜　编译器版本　｜　示例１　｜　示例２　　　｜<br />｜Ｗｉｎ２０００　｜　ＶＣ　　　　　　　　　　｜　７．１　　　｜　ＯＫ　　｜　ＯＫ　　　　｜<br />｜ＲＨＥＬ３　　　｜　ＧＣＣ　　　　　　　　　｜　３．２．３　｜　ＯＫ　　｜　ＯＫ　　　　｜<br />｜Ｗｉｎ２０００　｜　ＧＣＣ（ＭｉｎｇＷ）　　｜　３．４．２　｜　ＯＫ　　｜　启动时崩溃　｜<br />｜Ｗｉｎ２００３　｜　ＧＣＣ（Ｃｙｇｗｉｎ）　｜　３．４．４　｜　ＯＫ　　｜　启动时崩溃　｜<br />－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－<br />&#12288;&#12288;对于“示例2代码”造成的崩溃，经过简单排查，基本可以推断是 cout 滞后构造导致（也就是用到 cout 时，它还没生出来）。而且 GCC 3.4.2 这个版本是2004年出品的，应该不算太老啊（至少 C++ 03 标准已经发布一年了）。从上面的结果看，Linux 上版本较老的 GCC 反而没有问题。所以俺【<b>猜测</b>】：或许 GCC 在 Windows 上的移植版本有这个缺陷（仅仅是猜测啊）。<br />&#12288;&#12288;由于时间关系，没来得及深入研究。如果有同学不信，可以找个类似的环境试验一下（没准儿最后发现是俺搞错了，也有可能哦）。另外，想打破砂锅的同学，可以去琢磨一下出问题的编译器，看看它们的内部实现。<br /><br /><h2>★总结</h2><br />&#12288;&#12288;根据上述的情况，俺个人建议：如果你的代码有全局对象，并且你的代码【可能】会跨编译器，那就避免在全局对象的构造函数和析构函数中使用标准流类库的那八个玩意儿（包括“cout、cerr、clog”等）。<br />&#12288;&#12288;毕竟这八个全局对象，都有对应的标准 C 替代品，并不是不可替代的嘛。大伙儿犯不着冒险嘛。如果你确实舍不得流式操作符（&lt;&lt; 和 &gt;&gt;）或者确实看不惯 printf 的变参，你可以用字符串流先格式化好，再用标准 C 的函数输出嘛（也就多一两行代码而已嘛）。<br /><br /><br /><h2>★附录：测试代码</h2><br />&#12288;&#12288;最后附上示例代码，供有兴趣的同学尝试。大伙儿如果有新的发现，欢迎在本文留言告知俺。<br /><br /><h3>◇示例1代码</h3><br /><div class="source"><pre><span></span><span class="cp">#include</span> <span class="cpf">&lt;iostream&gt;</span><span class="cp"></span><br /><span class="k">using</span> <span class="k">namespace</span> <span class="n">std</span><span class="p">;</span><br /><br /><span class="k">class</span> <span class="nc">CFoo</span><br /><span class="p">{</span><br /><span class="k">public</span><span class="o">:</span><br />    <span class="n">CFoo</span><span class="p">()</span><br />    <span class="p">{</span><br />        <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">&quot;CFoo&quot;</span> <span class="o">&lt;&lt;</span> <span class="n">endl</span><span class="p">;</span><br />    <span class="p">}</span><br /><br />    <span class="o">~</span><span class="n">CFoo</span><span class="p">()</span><br />    <span class="p">{</span><br />        <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">&quot;~CFoo&quot;</span> <span class="o">&lt;&lt;</span> <span class="n">endl</span><span class="p">;</span><br />    <span class="p">}</span><br /><span class="p">};</span><br /><br /><span class="n">CFoo</span> <span class="n">g_foo</span><span class="p">;</span><br /><br /><span class="kt">int</span> <span class="nf">main</span><span class="p">()</span><br /><span class="p">{</span><br />    <span class="k">return</span> <span class="mi">0</span><span class="p">;</span><br /><span class="p">}</span><br /></pre></div><br /><h3>◇示例2代码</h3><br /><div class="source"><pre><span></span><span class="k">class</span> <span class="nc">CFoo</span><br /><span class="p">{</span><br /><span class="k">public</span><span class="o">:</span><br />    <span class="n">CFoo</span><span class="p">();</span><br />    <span class="o">~</span><span class="n">CFoo</span><span class="p">();</span><br /><span class="p">};</span><br /><br /><span class="n">CFoo</span> <span class="n">g_foo</span><span class="p">;</span><br /><br /><span class="cp">#include</span> <span class="cpf">&lt;cstdio&gt;</span><span class="cp"></span><br /><span class="cp">#include</span> <span class="cpf">&lt;iostream&gt;</span><span class="cp"></span><br /><span class="k">using</span> <span class="k">namespace</span> <span class="n">std</span><span class="p">;</span><br /><br /><span class="n">CFoo</span><span class="o">::</span><span class="n">CFoo</span><span class="p">()</span><br /><span class="p">{</span><br />    <span class="n">puts</span><span class="p">(</span><span class="s">&quot;puts CFoo&quot;</span><span class="p">);</span><br />    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">&quot;cout CFoo&quot;</span> <span class="o">&lt;&lt;</span> <span class="n">endl</span><span class="p">;</span><br /><span class="p">}</span><br /><br /><span class="n">CFoo</span><span class="o">::~</span><span class="n">CFoo</span><span class="p">()</span><br /><span class="p">{</span><br />    <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">&quot;cout ~CFoo&quot;</span> <span class="o">&lt;&lt;</span> <span class="n">endl</span><span class="p">;</span><br />    <span class="n">puts</span><span class="p">(</span><span class="s">&quot;puts ~CFoo&quot;</span><span class="p">);</span><br /><span class="p">}</span><br /><br /><span class="kt">int</span> <span class="n">main</span><span class="p">()</span><br /><span class="p">{</span><br />    <span class="k">return</span> <span class="mi">0</span><span class="p">;</span><br /><span class="p">}</span><br /></pre></div><div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/02/cxx-object-destroy-with-io-stream.html">https://program-think.blogspot.com/2009/02/cxx-object-destroy-with-io-stream.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/cxx-object-destroy-with-process.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>C++ 对象是怎么死的？进程篇 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">C++ 对象是怎么死的？进程篇</a></h1>
-<div class="post-info"><span class="date-header">2009-02-25</span><a href="../../tags/E7BC96E7A88B.html" class="tag">编程</a> <a href="../../tags/E7BC96E7A88B.C.html" class="tag">编程.C</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;我承认这个帖子的名称有标题党的嫌疑，但是暂时想不出更好的名称了，只好先这样了 :-(<br />&#12288;&#12288;由于前天的帖子聊了<a href="../../2009/02/multi-process-vs-multi-thread.html" target="_blank">架构设计的多进程问题</a>，所以今天想起来要聊一下与“C++进程终止”相关的那些事。与前几个 C++ 帖子的风格类似，今天聊的内容，尽量局限于标准 C++ 范畴，尽量不涉及特定的操作系统平台。<a name='more'></a><!--program-think--><br /><br /><h2>★关于进程的三种死法</h2><br />&#12288;&#12288;由于今天讲的是“进程篇”，自然得先搞明白进程的几种死法。其实进程和大活人一样，也有三种死法，分别是“自然死亡、自杀、它杀”。这三种死亡方式具体如下：<br /><br /><h3>◇自然死亡</h3><br />&#12288;&#12288;望文生义，自然死亡就是最自然的进程退出方法。具体表现为通过return语句结束main函数。由于这种方法最优雅（后面会说），如果没有其它特殊原因，强烈建议采用这种死法。<br /><br /><h3>◇自杀</h3><br />&#12288;&#12288;所谓的自杀，就是进程自己调用某些 API 来自行了断。在标准 C++ 中，这几个函数（exit、abort、terminate、unexpected）可以用于进程自杀。如果没有额外设置，unexpected 函数默认会调用 terminate 函数，terminate 函数默认会调用 abort 函数。所以自杀的方式基本上也就是 exit 和 abort 两种。exit 相对 abort 来说温和一些，所以下文称 exit 为<b>温和自杀</b>；相对地，把 abort 称为<b>激进自杀</b>。<br /><br /><h3>◇它杀</h3><br />&#12288;&#12288;它杀其实也挺好理解，就是当前进程被其它进程杀死。标准 C++ 没有提供用于它杀的 API 函数，因此常用的方法是通过某些跨平台的库（如 ACE）提供的 API 函数或者调用某些外部命令（如 Posix 系统的 kill 命令）来实现。<br />&#12288;&#12288;上面说了这几种死法，有同学要问了：进程不同的死法和 C++ 对象有什么关系捏？其实关系大大滴，请听我细细道来。<br /><br /><h2>★类对象的析构（销毁）</h2><br />&#12288;&#12288;首先把类对象分为三种：局部非静态对象、局部静态对象、非局部对象（出于习惯，以下简称<b>全局对象</b>）。对于尚不清楚这几种对象差异的同学，请先找本 C++ 入门书拜读一下。<br />&#12288;&#12288;进程不同的死法对于这几种对象是否能销毁会有很大的影响。请看如下的对照表：<br />－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－<br />｜　　　　　｜　局部非静态对象　｜　局部静态对象　｜　全局对象　｜<br />｜自然死亡　｜　能　　　　　　　｜　能　　　　　　｜　能　　　　｜<br />｜温和自杀　｜　不能　　　　　　｜　能　　　　　　｜　能　　　　｜<br />｜激进自杀　｜　不能　　　　　　｜　不能　　　　　｜　不能　　　｜<br />｜它杀　　　｜　不能　　　　　　｜　不能　　　　　｜　不能　　　｜<br />－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－<br />&#12288;&#12288;从这个对照表可以看出，激进自杀和它杀的效果类似（各种类对象都【无法】正常销毁）。所以我们在写程序时要极力避免上述这两种情况。<br />&#12288;&#12288;另外，温和自杀也有不爽之处：不能正确地销毁局部非静态对象。准确地说，应该是：在调用exit之前已经构造但是尚未析构的<b>局部非静态</b>对象将再也不会被析构。所以温和自杀也要避免使用。<br />&#12288;&#12288;综上所述，最正经、最靠谱的死法就是第一种：自然死亡。<br /><br /><h2>★析构的顺序</h2><br />&#12288;&#12288;那么，是不是只要让进程自然死亡就万事大吉了？非也！即使所有的类对象都会被析构，还有另一个棘手的问题：析构的顺序。<br />&#12288;&#12288;先来看下面一个例子：<br /><br /><div class="source"><pre><span></span><span class="k">class</span> <span class="nc">CFoo</span><br /><span class="p">{</span><br /><span class="k">public</span><span class="o">:</span><br />    <span class="n">CFoo</span><span class="p">()</span><br />    <span class="p">{</span><br />        <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">&quot;CFoo&quot;</span> <span class="o">&lt;&lt;</span> <span class="n">endl</span><span class="p">;</span><br />    <span class="p">}</span><br /><br />    <span class="k">virtual</span> <span class="o">~</span><span class="n">CFoo</span><span class="p">()</span><br />    <span class="p">{</span><br />        <span class="n">cout</span> <span class="o">&lt;&lt;</span> <span class="s">&quot;~CFoo&quot;</span> <span class="o">&lt;&lt;</span> <span class="n">endl</span><span class="p">;</span><br />    <span class="p">}</span><br /><span class="p">};</span><br /></pre></div><br />&#12288;&#12288;上述示例挺简单的（有效代码仅6行），大伙儿能看出有什么问题吗？（如果你一眼就看出问题之所在，恭喜你——你的 C++ 水平够高，后面的内容你不用看了）<br />&#12288;&#12288;对于用户定义的全局对象，在 C++ 标准中并【没有】规定它们构造和析构的先后顺序；对于诸如标准输入输出流的 cout、cerr 等全局对象，在 C++ 03 标准中（27.4.2.1.6章节）有提及如何保证它们在最后析构。但由于某些老式编译器并未完全遵照标准实现，导致标准输入输出流的几个全局对象【有可能】被提前析构。<br />&#12288;&#12288;基于上述原因，假如 CFoo 类也定义了一个全局对象 g_foo。当 g_foo 析构的时候，cout 对象【有可能】已经先死了（取决于具体的环境，详见《<a href="../../2009/02/cxx-object-destroy-with-io-stream.html">关于标准输入输出流的进一步探讨</a>》）。在这种情况下，CFoo 析构函数的打印语句由于引用了已死的对象，可能会导致【不可预料的后果】（比如进程崩溃）。<br />&#12288;&#12288;从上面的例子可以看出，如果你在程序中使用了全局对象或者静态对象，那你要非常小心地编写相关 class/struct 的析构函数代码，尽量【不要】在它们的析构函数中引用其它的全局对象或静态对象。当然啦，假如能避免使用全局对象和静态对象，就更好了。<br />&#12288;&#12288;另外，在 C++ 经典名著《Modern C++ Design》的第6章详细描述了关于单键/单例（Singleton）销毁的一些细节、场景及解决方法。大伙儿可以去拜读一下。<br />&#12288;&#12288;下一个帖子，咱们来聊一下<a href="../../2009/03/cxx-object-destroy-with-thread-win32.html">和线程有关的C++对象是怎么死的</a>。<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/02/cxx-object-destroy-with-process.html">https://program-think.blogspot.com/2009/02/cxx-object-destroy-with-process.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/daily-build-0-overview.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>软件工程进阶之每日构建[0]：概述 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">软件工程进阶之每日构建[0]：概述</a></h1>
-<div class="post-info"><span class="date-header">2009-02-16</span><a href="../../tags/E7BC96E7A88B.html" class="tag">编程</a> <a href="../../tags/E7BC96E7A88B.E8BDAFE4BBB6E5B7A5E7A88B.html" class="tag">编程.软件工程</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;在昨天的帖子《<a href="../../2009/02/6.html">正确地做事(善用工具)</a>》里提到了代码提交频度的问题。当时俺特别强调了【<b>要保证提交的代码能编译通过</b>】，理由是“对于每日构建很重要”。估计列位看官中，不太熟悉【每日构建】的，大有人在；而且国内停留在手工作坊阶段的软件公司，为数也不少。因此今天咱们就来说一下“每日构建”这个话题。假如你平时已经很善于运用“每日构建”这一有效的手段，可以直接略过本系列，去看其它帖子。<a name='more'></a><!--program-think--><br /><br /><br /><h2>★什么是“每日构建”？</h2><br />&#12288;&#12288;每日构建在洋文里也称为“Daily Build”或者“Nightly Build”。具体定义请看“<a href="https://en.wikipedia.org/wiki/Daily_build" target="_blank" rel="nofollow">这里</a>”。<br />&#12288;&#12288;通俗地说，就是每天都把【整个】软件项目【自动】编译一下，最终生成的产出物必须和交付到用户手中的一样（比如你最终提交给用户的是一个安装程序，那就必须在开发过程中每天编译出一个安装包）。<br /><br /><br /><h2>★“每日构建”举例</h2><br />&#12288;&#12288;为了表明每日构建是一个很有效的手段，给大伙举几个知名软件公司或者著名开源项目的例子：<br />1、微软公司内部几乎所有产品的开发过程，都会使用每日构建。<br />2、俺不确定 Google 所有的产品是否都采用，但至少 Chrome 浏览器已经采用每日构建。<br />3、知名的开源组织 Mozilla 也大量使用每日构建。<br />4、知名的 Linux 发行版 Ubuntu 也使用每日构建。<br />......<br /><br />&#12288;&#12288;上面这个列表还可以罗列很长。<br />&#12288;&#12288;举这么多例子，无非想说：每日构建是一种牛逼的软件工程手段。尤其对于复杂项目和大型团队，它的好处更加明显。看到这儿，有同学可能要问了，具体有些什么好处捏？请看“<a href="../../2009/02/daily-build-1-advantage.html">软件工程进阶之每日构建[1]：好处和优点</a>”。<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/02/daily-build-0-overview.html">https://program-think.blogspot.com/2009/02/daily-build-0-overview.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/daily-build-1-advantage.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>软件工程进阶之每日构建[1]：好处和优点 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">软件工程进阶之每日构建[1]：好处和优点</a></h1>
-<div class="post-info"><span class="date-header">2009-02-16</span><a href="../../tags/E7BC96E7A88B.html" class="tag">编程</a> <a href="../../tags/E7BC96E7A88B.E8BDAFE4BBB6E5B7A5E7A88B.html" class="tag">编程.软件工程</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;上一个帖子《<a href="../../2009/02/daily-build-0-overview.html">软件工程进阶之每日构建[0]：概述</a>》提到说每日构建是一种很牛X的软件工程手段。本帖子就来说说它到底有多牛X。为了加深大伙儿的印象，俺先来说一些陈年往事。<a name='more'></a><!--program-think--><br /><br /><h2>★一个反面教材</h2><br />&#12288;&#12288;话说上世纪末，俺还在一家小公司干活，并参与开发了一个 C++ 项目。当时公司的流程是：<br />开发人员写好代码，自己编译好，丢给测试人员测试；<br />测试人员如果发现bug，口头通知开发人员改；<br />开发人员改好 bug，再丢给测试人员测试<br />......<br /><br /><h3>◇弊端1——开发的混乱</h3><br />&#12288;&#12288;有一天，开发组的小头目找来程序员甲。<br /><blockquote>>>小头目：你负责的 XX 功能完成了没有？<br />>>程序员甲：早做完啦！<br />>>小头目：那测试人员乙怎么说一直没看到 XX 功能？<br />>>程序员甲：不会吧！我去瞧瞧。</blockquote>若干分钟后，程序员甲回来。<br /><blockquote>>>程序员甲：不好意思，编译好的 EXE 我只发给了测试人员丙，忘记发给测试人员乙了。<br />>>小头目：!@#$%^&amp;*（此处省略15字）</blockquote><br /><h3>★弊端2——测试的混乱</h3><br />&#12288;&#12288;另一天刚上班。<br /><blockquote>>>测试人员甲：今天开发提交的 XX.EXE 怎么一运行就崩溃？<br />>>测试人员乙：有吗？我这儿好好的呀！<br />>>测试人员甲：真见鬼！我找开发问一下。</blockquote>&#12288;&#12288;经过若干分钟打听，知道 XX.EXE 是程序员丙负责，于是找来程序员丙。<br /><blockquote>>>测试人员甲：为啥你做的 XX.EXE 一运行就崩溃？<br />>>程序员丙：有这回事？！让我看看你的环境。</blockquote>&#12288;&#12288;程序员丙在测试人员甲的机器上研究了 N 刻钟后。<br /><blockquote>>>程序员丙：你是猪脑啊，你没有更新 XXX.DLL，害我浪费这么长时间！<br />>>测试人员甲：你才是猪脑！我怎么知道 XX.EXE 会用到 XXX.DLL？</blockquote>&#12288;&#12288;然后两人开始对骂......<br /><br /><h3>◇弊端3——集成的混乱</h3><br />&#12288;&#12288;项目交付日期临近了，开发人员都在忙着改 bug，测试人员都在忙着复测 bug，没有人手准备安装包。于是，安装包的制作一直拖到项目交付的前一天才开始搞。<br />&#12288;&#12288;制作安装包本身倒是很快，半天就搞定。但是......<br /><blockquote>>>小头目：做好的安装包应该没什么问题吧？<br />>>测试人员丙：呃，这个，这个......好像装出来的软件有问题，一运行直接崩溃了。<br />>>小头目：额滴神啊！还愣着干嘛，快去查原因！！！今天不搞定大家不许回家！！！</blockquote>&#12288;&#12288;然后开发和测试通力协作，经过艰苦卓绝的努力，到了午夜时分，终于发现：有个 DLL 竟然是 Debug 版本！<br />&#12288;&#12288;有同学可能会问：为啥平时测试的时候没发现这个问题捏？<br />&#12288;&#12288;因为平时团队里面都使用 Debug 版本，方便用 ASSERT 断言。到了作安装包那天，照道理应该统一编译 Release 版本，但是有个家伙遗漏了，所以混了一个 Debug 版本的 DLL 在里面。等安装完运行程序时，该 DLL 动态加载失败，所以程序就崩溃鸟。<br /><br /><br /><h2>★每日构建如何解决上述弊端？</h2><br />&#12288;&#12288;俺上面说的这些情形，到今天为止，还在很多公司内部上演。那为啥每日构建能搞定上面这些问题捏？且听俺细细道来：<br /><br /><h3>◇针对“开发的混乱”</h3><br />&#12288;&#12288;对于每日构建的流程，开发人员只要负责提交代码到代码库中，【不】需要挨个给测试人员提供编译后的二进制文件。<br />&#12288;&#12288;因此“弊端1”的问题（提交给测试的文件有遗漏）就迎刃而解了。<br /><br /><h3>◇针对“测试��混乱”</h3><br />&#12288;&#12288;在开发阶段，由于测试拿到的程序都是自动编译出来的，因此保证了所有测试人员拿到的是【统一的】运行程序，并且这个程序和代码库中最新的代码是相对应的。<br />&#12288;&#12288;在测试阶段，每一个开发人员修复了 Bug 之后，都必须把改过的代码提交到代码库；然后通过“自动编译”，修复了 Bug 的二进制软件包才会到测试人员手中。如果某个开发人员改了 Bug 但是没有提交代码，那么在测试人员看来，相当于他的 Bug 一直没有改，因此他的 Bug 就一直不会被关闭。<br />&#12288;&#12288;所以“弊端2”的情况也不会出现。<br /><br /><h3>◇针对“集成的混乱”</h3><br />&#12288;&#12288;对于每日构建来说，每天都会生成安装包（或者“安装光盘的ISO镜像”）。也就是说，从项目开始开发的那天起，每天都在进行集成（这就是传说中的【持续集成】）。因此，集成的问题，在一开始就会暴露出来，而不用等到项目后期。<br /><br /><br />&#12288;&#12288;其实每日构建的好处除了上述三点（这三点俺认为比较重要），还有其它很多，大伙儿可以自己再琢磨一下。<br />&#12288;&#12288;<a href="../../2009/02/daily-build-2-prepare.html">后面一个帖子</a>，俺把每日构建需要的准备工作介绍一下。<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/02/daily-build-1-advantage.html">https://program-think.blogspot.com/2009/02/daily-build-1-advantage.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/daily-build-2-prepare.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>软件工程进阶之每日构建[2]：准备工作 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">软件工程进阶之每日构建[2]：准备工作</a></h1>
-<div class="post-info"><span class="date-header">2009-02-17</span><a href="../../tags/E7BC96E7A88B.html" class="tag">编程</a> <a href="../../tags/E7BC96E7A88B.E8BDAFE4BBB6E5B7A5E7A88B.html" class="tag">编程.软件工程</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;<a href="../../2009/02/daily-build-1-advantage.html">上一个帖子</a>务虚了一下每日构建的几个主要好处。今天开始来说点实在的：也就是每日构建具体要如何开始搞，要做哪些准备工作（如果你所在的团队已经在用每日构建，你可以跳过这个帖子）。<a name='more'></a><!--program-think--><br />&#12288;&#12288;每日构建不比其它纯技术的玩意儿，它是一个集体行为，它会改变包括“编程人员、测试人员、产品人员”等一堆人的工作模式。所以如果你想在公司里推广它，首先得掂量一下自己有几斤几两。一般来说，至少要做到项目主管或部门主管之类的级别，才有可能推得动。假设你尚未达到这种重量级，那看完本帖就算数，不可轻举妄动，切记、切记！<br />&#12288;&#12288;说到这里，有些涉世未深的同学可能有疑惑了，俺简单解释一下：假如你所在的公司非常地优秀、从谏如流、没有等级观念、易于接受新事物。且不说这样的公司在中国很少，即使你三生有幸正好待在这样的公司，公司里多半早就用上了每日构建，因此也轮不到你去操心了；反之，如果你的公司言路不畅、等级森严、抵触新事物，你在分量不够的情况下贸然跳出来，立马被一棍子打死。<br />&#12288;&#12288;好像有点跑题了，下面言归正传。本文会根据“管理、人员、硬件、软件”这4个维度，挨个介绍一下。<br /><br /><h2>★管理问题</h2><br />&#12288;&#12288;所谓管理问题，就是推行每日构建先要获得公司<b>实权</b>人物的撑腰，这点非常重要。根据俺以往的经验，要改变这么多人的工作习惯，必定会遭到极大的阻力、遭到各种质疑。一不小心就会被人家的口水给淹死。<br />&#12288;&#12288;那如何让公司的老大支持它捏？你可以把以前由于缺乏每日构建所导致的种种负面问题（这时候<a href="../../2009/02/daily-build-1-advantage.html">上一个帖子</a>的几个案例就可以派上用场啦）向公司的老大哭诉（最好声泪俱下），要尽量让公司老大明白之前的种种问题已经对公司造成了重大的、不可估量的、无法弥补的损失......<br />&#12288;&#12288;如果你的运气好，老大一激动，就把这事给批了。然后你就可以拿着鸡毛当令箭，去干后面的事情了。<br />&#12288;&#12288;如果你的运气差：老大死活不表态支持你，那你只好暂时先放弃这一打算，后面几步也就不用搞了。<br /><br /><br /><h2>★人员问题</h2><br />&#12288;&#12288;假设你搞定了管理问题，接下来就是着手解决人员问题。主要包括两方面：人员培训和指派一个构建责任人。<br />&#12288;&#12288;人员培训主要就是告诉相关的人员，将来每日构建的流程如何，各色人等该如何分工，各自承担什么责任，出了差错如何解决等等（具体的技术内容下一个帖子细说）。培训时要尽量让大伙儿理解这玩意儿的【切身】好处（比如可以减少扯皮）。<br />&#12288;&#12288;构建责任人（一般是兼任，不一定需要全职）主要承担和每日构建相关软硬件的维护工作，大体类似 IT 运维支持人员。另外，如果你公司对源代码非常敏感的话，这个“构建负责人”就得挑一个靠得住的人来担任。<br /><br /><br /><h2>★硬件问题</h2><br />&#12288;&#12288;为了让整个流程能够走通，你得额外去申请一个发布服务器和<b>若干</b>个编译服务器（俺假定你公司已经有了单独的源代码服务器和 Bug 管理服务器）。<br />&#12288;&#12288;发布服务器大体类似于一个共享文件服务器，将来每日自动生成的东东（一般是安装包或光盘镜像）就自动存放到上面。由于需要保存一段时间内每天构建的安装包（或安装光盘镜像），因此发布服务器对硬盘的要求比较高，其它配置倒无所谓。<br />&#12288;&#12288;编译服务器主要是为了进行自动编译。假如你开发的是跨平台软件，可能会需要多个编译服务器（每种平台配一个）；假如你开发的产品比较复杂，用一台机器编译太慢，可以考虑用多台机器并行做（听说微软对 Windows 搞每日构建就是多台服务器并行编译的，否则24小时都编译不完）。编译服务器对 CPU 和内存的要求会比较高，其它配置倒无所谓。<br /><br /><br /><h2>★软件问题</h2><br />&#12288;&#12288;到了这一步，基本上万事俱备了。然后就可以找个程序员来搞定和每日构建相关的各种【脚本】。主要有下面几种脚本：<br />1、从源代码服务器取出最新的源代码到编译服务器<br />2、在编译服务器上，把源代码编译为二进制文件，再把二进制文件制作成安装包<br />3、把安装包传到发布服务器<br />4、对安装包进行简单的冒烟测试（此脚本属于可选）<br />&#12288;&#12288;这些脚本相对都比较简单，基本上一个中等程度的程序员就能搞定。<br /><br /><br />&#12288;&#12288;上述就是几个方面的准备工作，<a href="../../2009/02/daily-build-3-proces.html">下一个帖子</a>咱们来聊一下具体的流程。<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/02/daily-build-2-prepare.html">https://program-think.blogspot.com/2009/02/daily-build-2-prepare.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/daily-build-3-proces.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>软件工程进阶之每日构建[3]：流程 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">软件工程进阶之每日构建[3]：流程</a></h1>
-<div class="post-info"><span class="date-header">2009-02-19</span><a href="../../tags/E7BC96E7A88B.html" class="tag">编程</a> <a href="../../tags/E7BC96E7A88B.E8BDAFE4BBB6E5B7A5E7A88B.html" class="tag">编程.软件工程</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;在<a href="../../2009/02/daily-build-2-prepare.html">上一个帖子</a>已经介绍了几方面的准备工作，今天来说一下具体流程。对于流程的每一个环节，俺会强调一下容易出问题的地方。<a name='more'></a><!--program-think--><br /><br /><br /><h2>★提交代码到源代码管理服务器</h2><br />&#12288;&#12288;以下为了打字方便，把源代码管理系统简称为 RCS（Revision Control System）。<br />&#12288;&#12288;和老式的软件手工作坊不同，编程人员实现了某个功能点之后，不需要自己编译成二进制并提交给测试。取而代之的是，把代码提交到 RCS。凡是使用过RCS 的人，都应该知道如何提交代码，俺这里就不细说了。<br />&#12288;&#12288;这个步骤的注意点有两个：一个是保证提交的代码是能编译通过的；另一个是提交频度的问题。<br />&#12288;&#12288;这两点在“<a href="../../2009/02/6.html#rcs">善用工具</a>”中有提及，这里再另外补充一点：有很多程序员在项目/工程中添加了文件之后，忘记在 RCS 里面也进行“添加操作”。虽然他/她本地的源代码都可以编译通过，但是在编译服务器上却编译失败。<br /><br /><br /><h2>★从源代码服务器取出代码到编译服务器</h2><br />&#12288;&#12288;这个步骤是脚本【自动】进行的，不需要人为干预。<br />&#12288;&#12288;为了让脚本能够自己跑起来，你通常需要在操作系统里面设置一个“计划任务”来启动该脚本。<br />&#12288;&#12288;该脚本主要进行代码的 checkout/update（不同的 RCS 软件叫法不同）操作。由于各种 RCS 软件都会提供命令行方式。所以该脚本只需要调用命令行就可以搞定。<br />&#12288;&#12288;这个步骤比较简单，一般不会出什么问题。在该脚本执行完之后，就开始【自动执行】后续的编译脚本。<br /><br /><br /><h2>★在编译服务器生成最终安装包</h2><br />&#12288;&#12288;这个步骤的脚本比较复杂，得把所有需要编译的模块都编译过，然后再组装成安装包。<br />&#12288;&#12288;几乎所有编译型的编程语言，在其开发工具包中都自带有命令行的编译程序（比如 JDK 中的 javac、Visual C++ 中的 cl、Flex 中的 mxmlc ...）。有了这些编译命令，再配合一些 make 工具（比如 Java 中的 Ant、VC 的 nmake、Posix上常用的 automake ...），就可以把一个工程编译成若干二进制文件。<br />&#12288;&#12288;在所有的项目都编译通过后，下一步就可以制作安装包了。大部分安装包软件（比如InstallShield、NSIS、RPM等）也都提供命令行方式。制作完安装包之后，这个步骤也就大功告成了。<br />&#12288;&#12288;这个步骤比较容易出问题的一个地方在于编译某个工程可能失败。一旦发现失败，就只能终止整个编译过程。这时候最好能【自动】发出一个十万火急的邮件，告知每日构建的负责人及相关项目/产品的负责人。然后那个导致编译失败的家伙就有的好看了：轻则被臭骂一顿，重则被通报批评。<br />&#12288;&#12288;为什么编译失败怎么严重捏？因为每日构建号称是软件开发过程的心跳，自动编译一失败，就相当于心跳停了（下一个工作日，测试人员的工作都要受影响，项目进度也因此受影响），那当然很严重的啦。所以，一般来说，规模越大的团队，对导致编译失败的处罚越重。<br />&#12288;&#12288;另一个容易出问题的地方在于增量编译。所谓增量编译就是在 Make 某个工程时，只编译修改过的源代码文件（主要是对比源代码文件的修改时间和对应二进制文件的修改时间来判断）。有些工具在判断增量编译时不够智能，导致本该编译的源代码文件没有编译（很容易引发诡异问题）。所以为了保险起见，俺一般都使用全编译（也就是编译某个工程之前，把对应的二进制文件都删除）。<br /><br /><br /><h2>★提交安装包到发布服务器</h2><br />&#12288;&#12288;假设安装包被成功编译出来，下一个步骤就是把安装包【自动】传输到发布服务器上。这个负责传输的脚本也是放在编译服务器上，在编译脚本执行完之后再被调用。<br />&#12288;&#12288;这个步骤一般也不会出什么差错，除非你公司的网络不稳定，导致传输过程文件损坏（那你只能自认倒霉了）。<br /><br /><br /><h2>★从发布服务器获取安装包进行冒烟测试（可选）</h2><br />&#12288;&#12288;如果你从来没听说过“冒烟测试”，请看“<a href="https://en.wikipedia.org/wiki/Smoke_testing" target="_blank" rel="nofollow">这里</a>”的介绍。<br />&#12288;&#12288;先说明一下，冒烟测试并【不是必做】的步骤，不过俺建议还是做一下比较好。冒烟测试是对软件最主要的功能进行一些简单基本的验证，保证自动编译出来的安装包是【基本可用】滴。如果冒烟测试不通过（和编译失败类似，也算是严重事故），则表明软件本身有严重 Bug，测试人员也就不用再费劲测试这个版本了（免得瞎忙乎）。<br />&#12288;&#12288;“冒烟测试”一般由某个专门的冒烟测试脚本负责。这个脚本一般放在测试服务器上，也是通过诸如计划任务来定时启动，然后从发布服务器上取下安装包，并进行相关的验证。<br /><br /><br /><h2>★测试人员从发布服务器上获取安装包并测试</h2><br />&#12288;&#12288;如果上述几个环节都还顺利，那么，下一个工作日上班的时候，测试人员就可以从发布服务器获取到安装包，并开始进行一天的测试工作了。<br />&#12288;&#12288;这里有一个小建议：“测试人员下载安装包并进行安装”最好也是通过脚本【自动】来做。这样的话，当测试人员上班的时候，当天凌晨做好的安装包就已经【自动】安装在测试机器上了，测试人员一打开电脑，就可以开始测试软件了。这不是很爽吗？<br /><br /><br />&#12288;&#12288;上述就是每日构建的几个主要步骤，<a href="../../2009/06/daily-build-4-tools.html">下一个帖子</a>聊一下与每日构建相关的工具。<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/02/daily-build-3-proces.html">https://program-think.blogspot.com/2009/02/daily-build-3-proces.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/defect-of-java-beginner-3-code-style.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>Java 新手的通病[3]：缺少良好的编程习惯 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">Java 新手的通病[3]：缺少良好的编程习惯</a></h1>
-<div class="post-info"><span class="date-header">2009-02-04</span><a href="../../tags/E7BC96E7A88B.html" class="tag">编程</a> <a href="../../tags/E7BC96E7A88B.Java.html" class="tag">编程.Java</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;上次聊了“<a href="../../2009/01/defect-of-java-beginner-2-oo.html">缺乏面向对象基本功</a>”，今天来说说编程习惯的问题。今天说的这些坏习惯大部分都是跨语言的（C++、Python 新手也有），而且大部分都需要靠平时不断地努力才能慢慢改掉。<a name='more'></a><!--program-think--><br /><br /><a name="naming"> </a><br /><h2>★随意地命名</h2><br />&#12288;&#12288;有些新手写程序，当需要定义某个变量名（也可能是函数名、类名、包名等）时，随意地一敲键盘，名字就起好了......若干星期后，碰到某 bug，再来看自己写的代码时，心中暗自嘀咕：“这代码是我写的吗？咋都看不懂捏？”<br />&#12288;&#12288;所以我常跟新来的菜鸟说，命名不规范害死人啊！鉴于该问题相当普遍，我整理了几种典型的作为反面教材，具体如下：使用单字母命名变量；使用一些没太大意义的变量名（例如 s1、s2、s3）；对同一个业务概念使用不同的术语/缩写（容易让读代码的人神经分裂）；使用拼音命名（如果你团队中有港台人士或者老外，就惨了）。<br /><br /><a name="copy_and_paste"> </a><br /><h2>★习惯于代码的 copy &amp; paste</h2><br />&#12288;&#12288;这是一个很普遍的问题。很多新手写代码的时候，如果发现要写的某个函数和前几天写的某个函数差不多，就把原来的那个函数贴过来，然后稍微改几下，心中还暗喜：“又快速搞定了一个功能”......<br />&#12288;&#12288;同学，如果你也喜欢这么干，可要注意了。这种做法是代码臭味（借用《重构 - 改善既有代码的设计》的提法）的主要来源，导致代码可维护性大大下降。当你将来需要增加功能或修改 bug 的时候，要同时改动多个地方，而那时你估计已经想不起来这砣代码有几个克隆了。<br /><br /><a name="magic_number"> </a><br /><h2>★Magic Number 满天飞</h2><br />&#12288;&#12288;如果你没有听说过“Magic Number”，先看“<a href="https://en.wikipedia.org/wiki/Magic_number_(programming)#Unnamed_numerical_constant" target="_blank" rel="nofollow">这里</a>”了解一下。<br />为了说明Magic Number的问题，咱找个例子来说事儿：假设有个业务逻辑中需要进行10秒的超时等待，你会怎么写这个sleep语句？我估计大部分人不外乎下面三种写法：<br />1、直接写上 <code>sleep(10*1000);</code> 了事<br />2、定义一个常量 <code>TIMEOUT_XXX = 10*1000;</code> 然后 <code>sleep(TIMEOUT_XXX);</code><br />3、在配制文件中加入一个超时项，然后程序读取配制文件获得超时值，然后调用 sleep。（此处提到的“配置文件”是广义的，泛指各种可用于存储配置信息的机制，如：xml 文件、ini 文件、数据库 ...）<br />&#12288;&#12288;如果你的做法类似于写法1，你多半喜欢随手硬编码。硬编码不光缺乏可读性，而且具有和“代码拷贝粘贴”类似的代码臭味（可能会存在多个 Magic Number 克隆），不利于日后维护。<br />&#12288;&#12288;至于写法2，比写法1稍好（至少可读性好了）。但是，将来一旦发生需求变更，要求在【运行时】调整超时间隔（甚至要求让用户来配制超时间隔），则写法2的缺点立马暴露无遗。<br /><br /><a name="coupling"> </a><br /><h2>★代码耦合度太大</h2><br />&#12288;&#12288;每当说到 MVC 或者设计模式，几乎每个 Java 开发人员都能说得头头是道？但是说归说，真正写代码的时候，鲜有人写出的代码是层次清楚的。至于说到代码耦合分别由哪些情况引起？什么是正交的设计？（关于耦合与正交设计，我后面会专门讨论一下）能完全搞明白的人就更少了。<br />&#12288;&#12288;所以很多 Java 新手的代码耦合度大也就不足为奇了。我曾经抽查过试用期员工的代码，各种业务逻辑纠缠在一起，代码臭味都要熏死人。想重构都无从下手，只好让他推倒重写。<br /><br /><a name="gc"> </a><br /><h2>★被 GC 宠坏</h2><br />&#12288;&#12288;由于 Java 在语言层面提供了内存的垃圾回收机制，程序员只管申请内存，不需要再关心释放的问题。因此很多新手养成了坏习惯，对于其它资源（比如数据库连接）也只申请不释放（有些人甚至天真地以为 JVM 会帮你搞定资源回收）。<br />&#12288;&#12288;还有些人虽然知道资源需要释放，但是常常忘记（比如写了打开数据库连接和相关代码，【即将】写关闭数据库连接时，突然有人叫你去吃中饭，回来后就把这茬给忘了）。<br />&#12288;&#12288;这个坏习惯会导致资源的泄露，而资源泄露往往比内存泄露更要命。如果你写的程序是长时间运行的（比如运行在 Web Server 上），时间长了会由于资源耗尽而导致整个进程出问题。<br /><br /><br />下一个帖子，聊一下“<a href="../../2009/02/defect-of-java-beginner-4-exception.html">异常处理使用不当</a>”。<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/02/defect-of-java-beginner-3-code-style.html">https://program-think.blogspot.com/2009/02/defect-of-java-beginner-3-code-style.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/defect-of-java-beginner-4-exception.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>Java 新手的通病[4]：异常处理使用不当 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">Java 新手的通病[4]：异常处理使用不当</a></h1>
-<div class="post-info"><span class="date-header">2009-02-12</span><a href="../../tags/E7BC96E7A88B.html" class="tag">编程</a> <a href="../../tags/E7BC96E7A88B.Java.html" class="tag">编程.Java</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;上一个帖子讨论了“<a href="../../2009/02/defect-of-java-beginner-3-code-style.html">编程习惯的问题</a>”，今天来聊聊关于异常处理的话题。<a name='more'></a><!--program-think--><br /><br /><br /><h2>★空的 catch 语句块</h2><br />&#12288;&#12288;犯这种错误的人比较少，一般发生在刚学会 Java 或者刚参加工作不久的人身上。<br />&#12288;&#12288;所谓“空 catch 语句块”就是在 catch 语句块中没有对异常作任何处理（比如记错误日志），导致异常信息被丢弃/忽略。一旦程序不能正确运行，由于查不到任何 log 信息，只好从头看代码，靠肉眼找 bug。<br /><br /><br /><h2>★没有使用 finally</h2><br />&#12288;&#12288;很多人在 catch 语句之后不使用 finally 语句。由于在 try 语句中可能会涉及资源的申请和释放。如果在资源申请之后、资源释放之前抛出异常，就会发生资源泄露。<br />&#12288;&#12288;（资源泄露的严重性，<a href="../../2009/02/defect-of-java-beginner-3-code-style.html#gc">上一个帖子</a>已经聊过了）<br /><br /><br /><h2>★笼统的 catch 语句块</h2><br />&#12288;&#12288;有些人为了省事，只在自己模块的最外层代码包一个 try 语句块，然后 catch(Exception)。不管捕获到什么异常，都作统一 log 了事。这种做法比“空 catch 语句块”稍好，但由于不能对具体的异常进行具体处理，对一些可恢复的异常（下面会提到），丧失了恢复的机会。而且也可能导致上述提到的资源泄露的问题。<br /><br /><br /><h2>★使用函数返回值进行错误处理</h2><br />&#12288;&#12288;有些人放着 Java 的异常机制不用，而用函数返回值来表示成功/失败（比如：返回 true 表示成功、false 表示失败），简直是“捧着金碗要饭”。个人感觉，从 C 转到 Java 的人比较容易有此毛病。这种做法会导致如下几个问题：<br />1. 返回值一般用整数值或布尔值表示，传递的信息过于简陋；<br />2. 一旦调用者忽略了错误返回码，就会导致和“空 catch 语句块”类似的问题；<br />2. 对同一个函数的多处调用，都需要对返回值进行重复判断，导致代码冗余（代码冗余的坏处，<a href="../../2009/02/defect-of-java-beginner-3-code-style.html#copy_and_paste">上一个帖子</a>也已经聊过了）。<br /><br /><br /><h2>★不清楚“Checked Exception”和“Runtime Exception”的区别</h2><br />&#12288;&#12288;这个现象比较普遍，俺发现很多2年以上 Java 工作经验的人尚未完全搞明白两者的区别。看来这个问题得详细说一下。<br />当初Java的设计者有意区分这两种异常，是别有深意的。其中“Checked Exception”用于表示可恢复的异常（也就是你必须检查的异常）；而“Runtime Exception”表示不可恢复的异常（也就是运行时异常，主要是程序 bug 和致命错误，你【不需要】检查）。不过这种做法引来了很多争议（包括很多 Java 大牛），鉴于本帖子主要针对新手，以后再专门来聊这个争议的话题。<br />&#12288;&#12288;为了便于理解，下面我举一个例子来说明。假设你要写一个 Download 函数，根据传入的 URL（String 参数）返回对应网页的内容文本。这时候有两种情况你需要处理：<br />1. 如果传入的 URL 参数是 null，这表明该函数的调用者出 bug 了，而程序本身的 bug 是很难在运行时自我恢复的。这时候 Download 函数必须抛出 Runtime Exception。并且 Download 函数的调用者【不应该】尝试去处理这个异常，必须让它【尽早】暴露出来（比如让 JVM 自己终止运行）。<br />2. 如果传入的 URL 参数非 null，但是它包含的字符串不是一个合法的URL格式（可能由于用户输入错误导致）。这时候 Download 函数必须抛出 Checked Exception。并且 Download 函数的调用者必须捕获该异常并进行相应的处理（比如提示用户重新输入 URL）。<br /><br />上面就是几种常见的Java异常处理的误用。下一个帖子我��来聊一下“<a href="../../2009/05/defect-of-java-beginner-5-jvm.html">对虚拟机（JVM）了解不足</a>”。<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/02/defect-of-java-beginner-4-exception.html">https://program-think.blogspot.com/2009/02/defect-of-java-beginner-4-exception.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/from-surface-to-essence.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>学会透过现象看本质，即使现象有时候挺诡异 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">学会透过现象看本质，即使现象有时候挺诡异</a></h1>
-<div class="post-info"><span class="date-header">2009-02-02</span><a href="../../tags/E5ADA6E4BC9AE6809DE88083.html" class="tag">学会思考</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;最近看到一个【汽车对冰淇淋过敏】的小故事（<a href="http://www.plant-maintenance.com/articles/pontiac.shtml" target="_blank" rel="nofollow">原文在此</a>），转述如下：<br /><blockquote>&#12288;&#12288;某汽车公司收到投诉信，用户抱怨了一个匪夷所思的经历：<br />&#12288;&#12288;他每晚都从家里开车去商店买冰淇淋。如果买的是香草冰淇淋，则回家时汽车就无法发动；如果买其它口味的冰淇淋，则汽车可以正常发动。天天如此。该用户怀疑这款汽车是否对香草冰淇淋过敏。<a name='more'></a><!--program-think--><br />&#12288;&#12288;汽车公司的头头觉得这太过诡异，不过还是派了一个工程师去用户家里调查原因。第一天，工程师和用户一起去买冰淇淋。在店里，工程师要求买香草口味，结果出来后，汽车果然不能发动。此后几天，工程师每次都和用户一起去买，每次都由工程师临时决定买什么口味。果不其然，凡是买了香草口味，汽车就无法发动；反之则可以。（由于是工程师临时决定购买的类型，可以排除用户搞恶作剧的可能）<br />&#12288;&#12288;这个工程师是一个理性的人，也不信神，当然不会相信汽车过敏这一说。但是他觉得有更深层的原因在起作用。此后，他每天晚上和该用户一起去买冰淇淋，每次他都详细记录往返的时间、途中踩油门和刹车次数、使用的汽油型号等各种信息。许多天后，他终于发现规律：凡是买香草口味的，在商店里面花的时间少（因为这个口味受欢迎，摆放的货架靠门口）。<br />&#12288;&#12288;于是问题就转化为：停车的时间短导致汽车不能正常发动。然后，工程师就轻易找到了原因（当停车时间太短，发动机依然很热而无法驱散气阻）。</blockquote><br />&#12288;&#12288;这个故事给我们几个启发：<br />1. <b>不要拒绝接受貌似很诡异、很离奇、很不可能的现象</b><br />俺手下的很多程序猿都曾经抱怨测试人员提交的某个bug太怪异，对这些bug不予承认。如果你也是程序猿，想一想自己是否也有类似情况？<br /><br />2. <b>要善于从一些细节发现规律，从而查出问题的根源</b><br />如果你是这个工程师，你能否通过细致的观察而发现其中的规律？<br /><br /><br /><b>俺博客上，和本文相关的帖子（需翻墙）</b>：<br />《<a href="../../2009/07/book-review-are-your-lights-on.html">书评：＜你的灯亮着吗？——找到问题的真正所在＞</a>》<br />《<a href="../../2015/05/Survivorship-Bias.html">思维的误区：幸存者偏见——顺便推荐巴菲特最著名的演讲</a>》<br />《<a href="../../2010/07/silent-proof.html">思维的误区：忽视沉默的大多数</a>》<br />《<a href="../../2012/03/think-what-how-why.html">用提问来促进思维——再谈 WHAT HOW WHY 三部曲</a>》<br /><div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/02/from-surface-to-essence.html">https://program-think.blogspot.com/2009/02/from-surface-to-essence.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/google-search-fatal-bug.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>从 Google 搜索的严重 bug 想开去 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">从 Google 搜索的严重 bug 想开去</a></h1>
-<div class="post-info"><span class="date-header">2009-02-01</span><a href="../../tags/IT.html" class="tag">IT</a> <a href="../../tags/IT.E4B89AE7958CE8AF84E8AEBA.html" class="tag">IT.业界评论</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;昨天晚上用 Google 查资料，看到所有的搜索结果都注明是恶意站点。第一反应以为自己眼花了；然后开始怀疑我的浏览器出问题，换了几个浏览器都是老样子；后来又想，会不会是我的 ISP 在搞鬼。等了十多分钟没解决，只好换百度查资料...<a name='more'></a><!--program-think--><br />&#12288;&#12288;今天早上看新闻才知道居然是 Google 的【人为】失误，居然是全球性的，居然持续了40多分钟。以下是 Google 的官方说法（<a href="https://googleblog.blogspot.com/2009/01/this-site-may-harm-your-computer-on.html" target="_blank" rel="nofollow">原文连接</a>）：<br /><blockquote>谷歌表示他们一直在和一家非盈利组织 StopBadware.org 合作，通过这个组织给出的名单对各个URL进行存在恶意软件的信息标注。这个组织的恶意网站名单是人工审核并添加，所以这份名单是人为生成而不是算法生成的。谷歌昨晚进行列表更新时，在下载回来的名单里，错误的出现了"/"这个URL地址，所以错误的将所有地址判断为恶意网站。</blockquote>&#12288;&#12288;比较有戏剧性的是，Google 提到的“非盈利组织 StopBadware.org”也发表声明：<br /><q>谷歌的恶意网站列表并非是我们提供的，而是其自己生成的。</q><br /><br />&#12288;&#12288;这件事情改变了我对 Google 的几个看法。<br />&#12288;&#12288;第1点：虽然我很看不起中国谷歌，但是美国 Google 在我看来一直是一个<b>优秀</b>的公司。现在它居然出现这么低级的错误（开发过商业Web网站的，应该都知道这有多低级），而且持续40多分钟才搞定。看来 Google“<b>优秀</b>”的名声要打折扣了。<br />&#12288;&#12288;第2点：假如 StopBadware 的说法成立，那我就得怀疑 Google 的诚信了。是否 Google 有意推卸责任给其它组织机构？看来 Google“<b>不做恶</b>”的名声要打折扣了。<br />&#12288;&#12288;第3点：Google 一直声称他的所有数据收集、处理、存储都是依靠程序进行的，不会涉及人工干预。我以前也一直猜测 Google 的恶意站点列表是依靠诸如神经网络、遗传算法、等等牛逼的算法来搞定的，现在 Google 居然承认是靠手工审核添加。看来 Google“<b>不采用人工干预</b>”的名声要打折扣了。<br />&#12288;&#12288;第4点：Google 一直在推动云计算，希望大伙儿尽可能地把桌面应用搬上云端。我本来觉得云计算这玩意也挺不错的（优点多多）。现在出了这档子事，我就得谨慎考虑一下了。假如我的个人数据都委托给 Google 代管，万一 Google 出个什么纰漏（比如被 Hacker 搞了），那可就悬了。<br /><div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/02/google-search-fatal-bug.html">https://program-think.blogspot.com/2009/02/google-search-fatal-bug.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/how-to-choose-opensource-project.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>如何选择开源项目？ - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">如何选择开源项目？</a></h1>
-<div class="post-info"><span class="date-header">2009-02-13</span><a href="../../tags/E7BC96E7A88B.html" class="tag">编程</a> <a href="../../tags/E7BC96E7A88B.E5BC80E6BA90E9A1B9E79BAE.html" class="tag">编程.开源项目</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;近几年开源项目越发普及，很多商业软件都逐渐引入开源项目。由于俺负责的产品线采用了不少开源项目（主要是 C++、Java、Python），这几年就经常会碰到开源项目选型的问题（从几个具有类似功能的开源软件项目中进行抉择）。今天我就大概聊一下自己的几点看法，供大伙儿参考。<br /><a name='more'></a><!--program-think--><br /><br /><h2>★License（授权协议、许可证）</h2><br />&#12288;&#12288;License 是很多人容易忽略的一个问题，所以我们先来聊一下 License 的问题。因为公司里面开发的软件大都属于商业软件（更严谨的叫法是“专属闭源软件”），根据开源协议和商业的冲突程度，可以分为三种：非常友好、不太友好、很敌对。下面分别介绍一下：<br /><br /><h3>◇对商业闭源软件“很敌对”的协议</h3><br />&#12288;&#12288;先说说“很敌对”的协议：GPL（详细解释请看“<a href="https://en.wikipedia.org/wiki/GNU_General_Public_License" target="_blank" rel="nofollow">这里</a>”）。GPL 和闭源软件是有严重冲突的。通俗地说，如果某个软件使用了基于 GPL 协议的【动态库或静态库】，则【整个软件】必须也用 GPL 协议发布（这就是大名鼎鼎的【GPL 传染性】）。也就是说——如果你开发的是【闭源】软件，一旦发现自己想用的某个开源库属于 GPL 协议，即使功能再强再好用，也只好忍痛割爱了。<br />&#12288;&#12288;在此郑重提醒大伙儿，【切莫】抱侥幸心理，偷偷使用。一旦被雪亮的群众眼睛所发现，不光害了自己的名节，公司的名节也不保。<br /><br /><h3>◇对商业闭源软件“不太友好”的协议</h3><br />&#12288;&#12288;因为 GPL 对于商业闭源软件太不友好了，估计当年很多开源库的作者怨声载道。GNU 组织为了缓和一下矛盾，搞出了一个折衷的 LGPL 协议（详细解释看“<a href="https://en.wikipedia.org/wiki/GNU_Lesser_General_Public_License" target="_blank" rel="nofollow">这里</a>”）。这个协议相对 GPL 来说，宽松了一些：商业闭源软件在【不公开】代码的前提下，可以在产品中使用 LGPL 的开源库。所以 LGPL 属于商业“不太友好”的协议。<br /><br /><h3>◇对商业闭源软件“很友好”的协议</h3><br />&#12288;&#12288;最后来说一下“非常友好”的协议，比较出名的有这几种：<a href="https://en.wikipedia.org/wiki/BSD_license" target="_blank" rel="nofollow">BSD</a>、<a href="https://en.wikipedia.org/wiki/Mozilla_Public_License" target="_blank" rel="nofollow">MPL（Mozilla）</a>、<a href="https://en.wikipedia.org/wiki/Apache_License" target="_blank" rel="nofollow">Apache</a>、<a href="https://en.wikipedia.org/wiki/MIT_License" target="_blank" rel="nofollow">MIT</a>。这些协议不但允许项目的使用者使用开源库，有些还允许对开源库进行修改并重新分发。因此用起来特别爽。上述这几个协议在细节上有些小差异，大伙儿可以去它们官网瞧一下。<br />&#12288;&#12288;另外，有些开源软件使用公共域授权（Public Domain，详细解释看“<a href="https://en.wikipedia.org/wiki/Public_domain" target="_blank" rel="nofollow">这里</a>”）。简单说，就是不作任何限制，软件的使用者可以为所欲为 :)<br /><br /><h3>◇其它协议</h3><br />&#12288;&#12288;上面提到的几种协议都是知名协议。还有少数开源项目不是采用知名协议，而是自己搞了一套协议。如果你碰到这种情况，就得硬着头皮认真读一遍协议上的洋文，看看它对于使用者有些什么限制了。<br /><br /><br /><h2>★技术层面的因素</h2><br />&#12288;&#12288;由于技术层面的考量和你所开发的软件密切相关，因此这方面的评判依据千差万别。我只能挑几个比较通用的说一下。<br />&#12288;&#12288;假如你开发的是跨平台的项目，那么你选择开源项目就得考虑它支持哪些平台（硬件平台、操作系统平台、数据库平台）。如果你需要支持的平台它不能支持，那就赶紧另找一个。<br />&#12288;&#12288;有时候编译器的支持也是考虑的指标之一。比如俺在“<a href="../../2009/01/cxx-cross-platform-develop-0-overview.html">C++ 的可移植性和跨平台开发</a>”里面提到的老式编译器问题。再比如俺曾经实施一个 Java 项目，用户的环境是 JDK 1.4。那么有些用了 Java 1.5 新语法的开源库就不能使用。<br />&#12288;&#12288;假如你开发的软件是性能敏感的，那选型的时候就要测试一下几个候选项目的性能指标。<br />&#12288;&#12288;现在安全问题越来越严重。如果你比较在意安全性的话，还得顺便调查一下候选项目是否有安全问题（比如缓冲区溢出的 bug、比如跨站脚本注入等）。<br /><br /><br /><h2>★普及程度（用户的人气）</h2><br />&#12288;&#12288;所谓的普及程度，就是看开源项目的用户占有率。当然大伙儿不是搞市场调查的，花钱请市场调查公司也不现实。简单的办法就是用搜索引擎大致搜一下，就能看出几个候选项目使用的广泛度了。<br />&#12288;&#12288;还有另外一个判断普及程度的方式，就是看某个开源项目是否被知名的软件或者公司采用。比如 Firefox（算是知名软件）采用 Sqlite 来存储页面缓存和 cookie，这至少可以从侧面反映出 Sqlite 项目的优秀程度。<br />&#12288;&#12288;对于若干个候选项目，显然要优先考虑普及度高的那个。因为某个项目普及度高，至少说明（但不绝对）它比较成熟、稳定、安全。而且用的人多了之后，相应的文档也会多一些，碰到问题也容易找到人咨询。<br /><br /><br /><h2>★活跃程度（开发的人气）</h2><br />&#12288;&#12288;这里说的“活跃”，是指开发层面而言。<br />&#12288;&#12288;一般来说，一个项目越活越，则新功能的推出越快，对提交 bug 的响应也越快。还有些项目，由于开发人员不再继续开发（可能开发人员厌倦了、可能开发人员太忙了），从而导致活跃度很低。<br />&#12288;&#12288;不过也有例外——有些项目由于已经非常完善了，因此反而活跃程度很低。俺印象中：最近几年 bzip2 就很少有更新，但它是非常优秀的压缩库。<br /><br /><br /><h2>★其它的风险</h2><br />&#12288;&#12288;最后来说说一些其它的风险。一般来说，只有当前几个因素都差不多的时候，才会来考虑其它风险。<br /><br /><h3>◇“单点故障”的风险</h3><br />&#12288;&#12288;（如果你【不】清楚“单点故障”是啥意思，先看“<a href="../../2015/04/Single-Point-of-Failure.html">这篇博文</a>”）<br />&#12288;&#12288;很多项目过于依赖【个人英雄主义——光靠着一两个大牛完成整个项目。一旦大牛出现意外，必然导致整个项目受到严重影响。典型的例子就是 ReiserFS 文件系统的创始人 Hans Reiser。这位老兄由于谋杀妻子的罪名成立，被判入狱15年（对 IT 八卦有兴趣的同学可以看“<a href="https://en.wikipedia.org/wiki/Hans_Reiser" target="_blank" rel="nofollow">这里</a>”）。导致 ReiserFS 项目受到严重影响。<br />&#12288;&#12288;顺便说一下：<br />&#12288;&#12288;这类风险在开源界有个专门的术语叫“<a href="https://en.wikipedia.org/wiki/Bus_factor" target="_blank" rel="nofollow">Bus Factor</a>”，翻译成“巴士因子”或“卡车系数”。指的是——项目中有多少个关键人物【同时】出车祸，才会导致项目瘫痪。<br /><br /><h3>◇商业风险</h3><br />&#12288;&#12288;还有些开源项目被商业公司收购后，由于种种原因（商业、管理、政治等）导致该开源项目受到不利影响。比如上星期听说 Michael Widenius（MySQL 共同创始人）和 Marten Mickos（MySQL 前任 CEO）从 Sun 离职。再加上去年10月走掉了的 David Axmark（MySQL 共同创始人）。估计对 MySQL 的影响不小。<br /><br />&#12288;&#12288;上述提到的几个考量指标，排在越前面的，权重越高。你在选型时需要综合考虑这几个因素。<br /><br /><br /><b>俺博客上，和本文相关的帖子（需翻墙）</b>：<br />《<a href="../../2019/03/Misunderstand-Free-and-Open-Source-Software.html">澄清“自由软件、开源软件”相关概念及许可证的误解</a>》<br />《<a href="../../2015/04/Single-Point-of-Failure.html">聊聊【单点故障】——关于“德国空难”和“李光耀”的随想</a>》<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/02/how-to-choose-opensource-project.html">https://program-think.blogspot.com/2009/02/how-to-choose-opensource-project.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/multi-process-vs-multi-thread.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>架构设计：进程还是线程？是一个问题！ - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">架构设计：进程还是线程？是一个问题！</a></h1>
-<div class="post-info"><span class="date-header">2009-02-22</span><a href="../../tags/E7BC96E7A88B.html" class="tag">编程</a> <a href="../../tags/E7BC96E7A88B.E5A49AE7BABFE7A88B.html" class="tag">编程.多线程</a> <a href="../../tags/E7BC96E7A88B.E69EB6E69E84.html" class="tag">编程.架构</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;就像莎士比亚的“To be, or not to be, that is the question”始终困扰着哈姆雷特，对于“进程还是线程？”这个问题，也经常困扰着那些进行软件架构设计的家伙。所以今天打算聊一下我对这个问题的体会。假如你还搞不清楚线程和进程的区别，请先找本操作系统原理的书好好拜读一下，再回来看帖。<br />由于这个问题很容易引发口水战，事先声明如下：多进程和多线程，无法一概而论地说谁比谁好。因此本帖主要描述<b>特定场景</b>（与我所负责的产品相关）下，进程和线程的权衡经验，仅供大伙儿参考。<a name='more'></a><!--program-think--><br />&#12288;&#12288;由于特定场景是本帖讨论的前提，先说说我目前负责的产品的特点：业务逻辑比较复杂、业务数据量比较大、对数据<b>实时</b>处理的性能要求比较高、对健壮性和安全性要求比较高、要求跨平台（包括操作系统、数据库）、某些情况下需要分布部署。<br />&#12288;&#12288;上面说了一大堆，其实有不少的应用系统符合上述特点，比如：某些网络游戏服务器、某些金融行业的业务系统、某些电子商务的交易系统等等。如果你正在从事的是类似的应用系统的设计，希望我下面介绍的经验对你有帮助。<br /><br /><h2>★进程【颗粒度】问题</h2><br />&#12288;&#12288;大伙儿应该明白，进程和线程都是处理并发（concurrency）的手段。对于上述这种比较复杂的系统，如果你企图全部用进程（见“注1”）或者全部用线程（见“注2”）来处理并发，估计会死得很难看。所以，关键问题就是如何在进程和线程之间进行平衡（也就是确定进程颗粒度的问题）。<br />&#12288;&#12288;注1<br />&#12288;&#12288;所谓“全部用进程”，就是所有的并发都使用进程实现（因此每个进程只有一个线程）。这种设计在某些平台上（比如 Windows）会导致严重的性能问题。<br />&#12288;&#12288;注2<br />&#12288;&#12288;所谓“全部用线程”，就是所有的并发都使用线程实现（因此整个系统只有一个进程）。这种设计的健壮性极差（一个致命错会导致整个系统崩溃），而且更别提分布部署了。<br /><br />&#12288;&#12288;我个人建议，尽量<b>以业务逻辑的单元来划分进程</b>。这样做的好处有如下几点：<br /><br /><h2>★“以业务逻辑为单元”划分进程的好处</h2><br /><h3>◇避免扯皮</h3><br />&#12288;&#12288;一般来说，某个固定业务逻辑的开发人员也是相对固定的。如果业务逻辑对应的某个进程崩溃了，测试人员容易快速定位肇事者，然后直接提交Bug给他/她。<br />&#12288;&#12288;反之，一个进程搞得太庞大，N 多人掺和在里面，一旦进程崩溃了，相关编程人员之间很容易互相扯皮，不利于维护安定团结的局面；另外，由于测试人员经常搞不清楚 Bug 属于谁，经常给错 Bug，也容易制造人民内部矛盾。<br />&#12288;&#12288;由此可以看出，【相对细】的进程颗粒度能够避免一些管理上的麻烦。由于 XXX 经常教导我们：“稳定压倒一切”，所以该优点列第一条。<br /><br /><h3>◇健壮性、容错性</h3><br />&#12288;&#12288;一般来说，开发人员的水平参差不齐，优秀的毕竟是少数（具体参见“<a href="../../2009/02/80-20-principle-0-overview.html">二八原理系列</a>”的帖子）。所以难免会有菜鸟程序员搞出低级错误，而有些低级错误是致命的，会导致进程的崩溃。<br />&#12288;&#12288;如果你是以业务逻辑划分进程，一个业务逻辑的进程崩溃，对其它业务逻辑的影响不大（除非是该业务逻辑的依赖方）；因此就不会出现“全部用线程”导致的弊端。<br /><br /><h3>◇分布式</h3><br />&#12288;&#12288;我常碰见的分布式部署需求，一般都是按照业务逻辑的维度来划分。���如系统中有一个认证模块，里面包含有敏感的用户认证信息。这时候客户就会要求把该模块单独部署在一台经过安全加固的主机中（以防阶级敌人搞破坏）。<br />&#12288;&#12288;如果是以业务逻辑为单位划分进程，要满足上述的部署需求就相对容易了（只要再配合恰当的进程间通讯机制，下面会提到）。<br />&#12288;&#12288;另外，支持分布式部署还可以顺带解决性能问题。比如某个业务逻辑模块特别消耗硬件资源（比如：内存、CPU、硬盘、带宽），就可以把它拿出去单独放一台机器上跑。<br /><br /><h3>◇跨编程语言</h3><br />&#12288;&#12288;这个好处可能很多人容易忽略。一般来说，每个编程语言都有各自的优缺点。如果你通过业务逻辑划分进程，就可以根据不同的业务逻辑的特点来选择合适的编程语言。<br />&#12288;&#12288;比如：对于性能敏感的模块，我就使用 C++ 搞定；而对于一些业务逻辑密集型的模块，则使用 Java 或 Python 开发。<br /><br /><h2>★进程间通讯（以下简称 IPC）问题</h2><br />&#12288;&#12288;既然不可能把整个系统放入一个进程，那就必然会碰到 IPC 的问题。下面就来说一下该如何选择 IPC。<br />&#12288;&#12288;各种操作系统里面，有很多稀奇古怪的 IPC 类型。由于要考虑跨平台，首先砍掉一批（关于 IPC 的跨平台问题，我在“<a href="../../2009/01/cxx-cross-platform-develop-0-overview.html">跨平台开发</a>”系列中会提到）。剩下的 IPC 类型中，能够进行数据传输的 IPC 就不多了，主要有如下几种：套接字（以下简称 Socket）、共享内存、管道、文件。<br />其中 Socket 是俺强烈推荐的 IPC 方式，理由如下：使用 Socket 可以天然地支持分布式部署；使用 Socket 可以比较容易地实现多种编程语言的混合（比如：C++、Java、Python、Flex 都支持 Socket）；使用 Socket 还可以省掉了一大坨“锁操作”的代码。<br />&#12288;&#12288;列位看官中，或许有人在担心 Socket 的性能问题，其实大可不必多虑。当两个进程在【本机】上进行 Socket 通讯时，由于可以使用 localhost 环回地址，数据不用经过物理网卡，操作系统内核还可以进行某些优化。这种情况下，Socket 相对其它几种IPC机制，不会有太大的性能偏差。<br />&#12288;&#12288;最后再补充一下，Socket 方式也可以有效防止扯皮问题。举个例子：张三写了一个进程 A，李四写了一个进程 B，进程 A 通过 Socket 方式发数据给进程B。突然有一天，两个进程的通讯出故障了。然后张三就说是李四接收数据出错；李四就说张三发送数据出错。这时候怎么办捏？很简单，随便找个 Sniffer 软件当场抓一下数据包并 Dump 出来看，问题就水落石出了。<br /><br /><h2>★为啥还要线程？</h2><br />&#12288;&#12288;上面说了这么多进程的好处，有同学要问了：“那线程有什么用捏？”总的来说，使用线程出于两方面的考虑：性能因素和编码方便。<br /><br /><h3>◇性能因素</h3><br />&#12288;&#12288;由于某些操作系统（比如 Windows）中的进程比较重型，如果【频繁】创建进程或者创建大量进程，会导致操作系统的负载过高。举例如下：<br />&#12288;&#12288;假设你要开发一个类似 Web Server 的应用。你针对每一个客户端请求创建一个对应的进程用于进行数据交互（是不是想起了古老的 CGI）。一旦这个系统扩容，用户的并发连接数一增加，你的应用立马死翘翘。<br />&#12288;&#12288;上面的例子表明，跨平台软件系统的进程数要保持相对稳定。如果你的进程数会随着某些环境因素呈线性增长，那就相当不妙了（顺带说一下，如果线程数会随着环境因素呈线性增长，也相当不妙）。而根据业务逻辑的单元划分进程，顺便能达到“进程数的相对稳定”的效果。<br /><br /><h3>◇编码方面</h3><br />&#12288;&#12288;由于业务逻辑内部的数据耦合比较紧密。如果业务逻辑内部的并发也用进程来实现，<b>可能</b>会导致大量的 IPC 编码（任意两个进程之间只要有数据交互，就得写一坨 IPC 代码）。这或许会让相关的编程人员怨声载道。<br />&#12288;&#12288;当然，编码方面的问题也不是绝对的。假如你的系统有很成熟且方便易用的IPC库，可以比较透明地封装IPC相关操作，那这方面的问题也就不存在了。<br /><br />&#12288;&#12288;写到这里，看看篇幅有点超，就此打住。大伙儿如有不同看法，请到评论中拍砖。<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/02/multi-process-vs-multi-thread.html">https://program-think.blogspot.com/2009/02/multi-process-vs-multi-thread.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/ria-review-flash-silverlight-javafx.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>三种主流 RIA 技术之争，你该如何选型？ - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">三种主流 RIA 技术之争，你该如何选型？</a></h1>
-<div class="post-info"><span class="date-header">2009-02-05</span><a href="../../tags/IT.html" class="tag">IT</a> <a href="../../tags/IT.E4B89AE7958CE8AF84E8AEBA.html" class="tag">IT.业界评论</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;前几天听说 Adobe 发布了用于 Flash Player 的 RTMP（实时消息协议），在“<a href="http://www.adobe.com/aboutadobe/pressroom/pressreleases/200901/012009RTMP.html" target="_blank" rel="nofollow">这里</a>”。乍一看，好像是一个不错的东东。号称有如下优点：支持高性能地把数据（主要是音频、视频）PUSH 给 Flash Player；支持 over HTTP 和 HTTPS。再联想到最近1-2年，微软在 Silverlight（详细介绍看“<a href="https://en.wikipedia.org/wiki/Silverlight" target="_blank" rel="nofollow">这里</a>”）上也是频频出击。而 Sun 也不甘寂寞，搞出了一个 JavaFX（2个月前刚发布，详细介绍见“<a href="https://en.wikipedia.org/wiki/JavaFX" target="_blank" rel="nofollow">这里</a>”）。看来RIA领域的竞争有白热化的趋势。干脆今天就来八卦一下这三个技术。<a name='more'></a><!--program-think--><br />&#12288;&#12288;有同学可能会问了，为啥不顺便提一下 AJAX 捏？主要是因为 AJAX 和那三个玩意儿有很大的差别，不属于同一个维度，没有可比性（绝没有贬低 AJAX 的意思）。所以今天暂且抛开不谈（下次如果有空再聊 AJAX）。<br /><br /><h2>★先说说 Flash/Flex</h2><br />&#12288;&#12288;Flash/Flex 早先是由 Macromedia 搞出来的。Adobe 目光独到，在2005年把 Macromedia 吞并了。于是 Flash/Flex 就成了 Adobe 的如意法宝。其实当初收购 Macromedia 的价格并不高，也就34亿美金。这个数字对微软来说是小意思，可惜当初微软真是瞎了眼，没有先下手。否则现在 RIA 市场的格局就是另外一番景象了。话说回来，Adobe 买下 Macromedia 后，对 Flash 也是下了大本钱，再加上那几年没有直接的竞争对手。因此到了2007年，Flash/Flex 已经成为 RIA 市场的事实标准，当时的 PC 占有率少说也有70%。而且开始进入手机市场。<br />&#12288;&#12288;目前 Flash/Flex 主要的优势一个是用户群大，还有一个是跨平台（包括操作系统、浏览器、移动设备）。<br />&#12288;&#12288;不过我这2-3年用下来，感觉 Flash/Flex 也有不少问题。一个主要的问题是语言的兼容性不够好，当初从 ActionScript2 迁移到 ActionScript3，团队里的人怨声载道（很多代码几乎要重写）。还有一个问题是功能不够强，让人感觉很不爽。比如至今不能够很好地支持多线程（仅支持异步回调）；比如不能很好地整合 PDF（照理说都是自家公司产品，整合应该不难）。<br /><br /><h2>★再说说 Silverlight</h2><br />&#12288;&#12288;估计是到了2006年后，微软发觉苗头不对，赶紧下大力气自己搞。在2007年底和2008年底分别发布了 Silverlight 1.0 和 Silverlight 2.0（3.0据说2009年也有望推出）。然后商务层面也接连出手：先是2008奥运期间与 NBC（美国国家广播公司）合作，用 Silverlight 进行赛事直播；接着在上个月美国总统就职典礼，也用上了 Silverlight。微软的意图非常明显，就是市场方面利用各种机会争夺用户占有率，弥补对 Flash 的劣势；技术方面不断强化功能，力图甩开 Flex，吸引开发人员加入。<br />&#12288;&#12288;要说 Silverlight 的优点，我觉得依托于 dotNET 是主要优势。借着 dotNET 这个靠山，Silverlight 能整合现有的某些语言（据说已能支持 JScript、<a href="https://en.wikipedia.org/wiki/IronPython" target="_blank" rel="nofollow">IronPython</a>、<a href="https://en.wikipedia.org/wiki/IronRuby" target="_blank" rel="nofollow">IronRuby</a>、VB）和库；还能够方便原有的 dotNET 程序员上手。Silverlight 在功能上也显得比 Flex 更强大（比如多线程和 3D 方面）。<br />&#12288;&#12288;不过依托于 dotNET 也导致了 Silverlight 的主要缺点：跨平台不够好。虽说现在有 Moonlight 的帮忙，但依然不够理想（尤其是对 Linux 的支持）。<br /><br /><h2>★最后顺便提一下 JavaFX</h2><br />&#12288;&#12288;坦白讲，JavaFX 实在是乏善可陈。Sun 的一个主要失策就在于后知后觉，跟进太慢。微软下手已经慢了，结果 Sun 比它还慢。而 Sun 在财力上又比微软差了很多（Sun 现在自身难保，根本没法像微软那样烧钱搞推广），做 IDE 也不如微软拿手。真是天时、地利、人和皆无。难怪连 Java 社区对它也热情不高（有 Java 大牛<a href="https://en.wikipedia.org/wiki/Bruce_Eckel" target="_blank" rel="nofollow">Bruce Eckel</a>的文章“<a href="http://www.artima.com/weblogs/viewpost.jsp?thread=234900" target="_blank" rel="nofollow">Does Anyone Really Care About Desktop Java?</a>”为证）。<br /><br /><h2>★结论</h2><br />&#12288;&#12288;假如你要开发一个 Web 系统，打算从上述三种 RIA 技术中挑选一个。那么你先要评估一下你的 Web 应用对跨平台的需求如何？如果你需要同时支持各种各样的客户端操作系统和浏览器，那强烈建议你选择 Flex（我的部门现在面临的就是这种情况）；反之，如果你铁定<b>只要</b>支持 Windows，或许也可以考虑 Silverlight。至于说 JavaFX，短期内就先不要考虑啦。<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/02/ria-review-flash-silverlight-javafx.html">https://program-think.blogspot.com/2009/02/ria-review-flash-silverlight-javafx.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/02/study-technology-in-three-steps.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>学习技术的三部曲：WHAT、HOW、WHY - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">学习技术的三部曲：WHAT、HOW、WHY</a></h1>
-<div class="post-info"><span class="date-header">2009-02-19</span><a href="../../tags/E5ADA6E4B9A0E696B9E6B395.html" class="tag">学习方法</a> <a href="../../tags/E5ADA6E4BC9AE6809DE88083.html" class="tag">学会思考</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;最近几天有些网友在邮件里面问我关于学习的问题。有好几个人觉得工作了几年，也学会了不少的类库、框架、甚至语言，但是感觉自己的能力没有太大的提高。因此今天来说一下我个人对这方面的体会，希望对大伙儿（尤其是新手）有帮助。<br />&#12288;&#12288;先声明一下，本帖子讨论的三部曲是指你已经选定了某个技术方向之后，该如何学习；至于如何选定技术方向，则属于另一个话题，不在今天的讨论之列。<br />&#12288;&#12288;我把学习归类为三个步骤：What、How、Why。经过我对周围同事和朋友的观察，大部分感觉自己技术没有提高的人，都仅仅停留在 WHAT 阶段。下面我把这三个步骤解释一下。<br /><a name='more'></a><!--program-think--><br /><br /><br /><h2>★第一步：WHAT</h2><br />&#12288;&#12288;所谓的“WHAT”也就是“What is it?”——这是最简单的层次。在这个层次，你要搞清楚某个东东是【什么】样子的？有【什么】用处？有【什么】特性？有【什么】语法？......<br />&#12288;&#12288;举例如下：<br /><blockquote>对于学习语言（比如 C++、Java、Python），大部分人都能够掌握基本的语法和标准库，然后用它写一些小程序（诸如二分查找、冒泡排序、简单文件操作等）。<br />对于学习类库（比如 JDBC 类库），大部分 Java 程序员都能明白 JDBC 主要包含哪些类，也能够用 JDBC 进行简单的数据库查询和增删改操作。</blockquote>&#12288;&#12288;由于这个步骤是最基本的，假如你连这都做不到（可能你的理解力不够好），也别在 IT 行业混了。<br />&#12288;&#12288;但是光会 What 是不够的。仅仅停留在这个步骤，导致了很多程序员【只知其然，不知其所以然】。这就是目前大部分开发人员的现状。<br /><br /><br /><h2>★第二步：HOW</h2><br />&#12288;&#12288;所谓的“HOW”就是“How to do?”。在这个层次，你要搞清楚某个东西，其内部是【如何】运作的？【如何】实现的？......<br />&#12288;&#12288;举例如下：<br /><blockquote>假如你在学习 C++ 语言，你是否搞明白函数传参数的实现机制？虚函数是如何实现？抛出异常时的栈回退是怎么回事？......<br />假如你在学习 Java 语言，你是否搞清楚 GC 如何实现？反射是如何实现？......<br />假如你在学习 JDBC 库，你是否清楚 JDBC Driver 的4种类型？不同游标类型的实现机制？事务的机制？......</blockquote>&#12288;&#12288;在这个阶段，你必须多想想类似这些问题。然后通过各种途径（参见“<a href="../../2009/01/2.html">关于自学能力</a>”的几个方法），把问题彻底搞清楚。自然而然，你的提高就会比较明显。而且如果碰到一些深层次的问题（比如性能优化），也就知道该如何去解决。<br />&#12288;&#12288;完成这个阶段之后，你基本上就属于该技术领域最优秀的20%的人（根据<a href="../../2009/02/80-20-principle-0-overview.html">二八原理</a>，80%的人不会去思考 HOW 的问题）。<br /><br /><br /><h2>★第三步：WHY</h2><br />&#12288;&#12288;一般来说，只有想清楚 HOW 之后，才能继续去考虑 WHY。<br />&#12288;&#12288;所谓的“WHY”，就是搞清楚某个东西【为什么】设计成这样？【为什么】不是另外的样子？这样的设计有什么讲究？......<br />&#12288;&#12288;说实在的，善于问“为什么”有一定的天赋成分？好像某个科学大牛曾经说过“提出问题有时候比解决问题更难”。一般来说，只有当你【深刻理解】了某个东西，才能够针对这个东东的【设计】问出一些问题。所以，我前面强调过，要先把 HOW 的问题搞清楚，再来考虑 WHY 的问题。<br />&#12288;&#12288;举例如下：<br /><blockquote>对于C++语言：为什么 C++ 没有类似 Java 的 finally 关键字？为什么当初发明 C++ 的时候没有考虑 GC？......<br />对于Java语言：为什么 Java 没有类似 C++ 的类析���函数？为什么 Java 要同时提供 String 和 StringBuffer 两个似乎冗余的类？......<br />对于Python语言：为什么 Python 不提供类似 C++/Java 的访问控制机制？......</blockquote>&#12288;&#12288;如果你能够【自己】问出诸如上述的“为什么”问题，并且能够通过各种途径找到解答，那你基本上已经吃透这个技术了，并且你已经【有可能】自己去【设计】一个类似的玩意儿了。到这时，你已经踏上了通向技术高手的康庄大道。<br /><br />&#12288;&#12288;由于本博客偏重 IT 方面，所以今天举的这些例子多半都是 IT 相关的。但这个“三部曲”在 IT 之外的行业和领域，其实也适用。如何举一反三，就看各位的悟性了。<br /><br /><br /><h2>★后续更新</h2><br />&#12288;&#12288;写完本文3年之后（2012），俺又写了一篇《<a href="../../2012/03/think-what-how-why.html">用提问来促进思维——兼谈【非】技术领域的 WHAT HOW WHY 三部曲</a>》，谈“IT 之外的行业和领域”，如何运用这三部曲。<br /><br /><br /><b>俺博客上，和本文相关的帖子（需翻墙）</b>：<br />《<a href="../../2012/03/think-what-how-why.html">用提问来促进思维——兼谈【非】技术领域的 WHAT HOW WHY 三部曲</a>》<br />《<a href="../../2019/10/Systematic-Learning.html">如何【系统性学习】——从“媒介形态”聊到“DIKW 模型”</a>》<br />《<a href="../../2013/09/knowledge-structure.html">如何完善自己的知识结构</a>》<br />《<a href="../../2009/07/book-review-are-your-lights-on.html">书评：＜你的灯亮着吗？——找到问题的真正所在＞</a>》<br />《<a href="../../2019/03/Why-Thinking-Hard-So-Hard.html">为什么独立思考这么难？——谈谈心理学的成因，并分享俺的经验</a>》<br />《<a href="../../2013/05/difference-between-fact-and-opinion.html">批判性思维扫盲：学会区分“事实”与“观点”</a>》<br />《<a href="../../2015/05/Survivorship-Bias.html">思维的误区：幸存者偏见——顺便推荐巴菲特最著名的演讲</a>》<br />《<a href="../../2010/07/silent-proof.html">思维的误区：忽视沉默的大多数</a>》<br />《<a href="../../2009/05/halo-effect.html">光环效应引发的认知误区</a>》<br />《<a href="../../2009/02/from-surface-to-essence.html">学会透过现象看本质，即使现象有时候挺诡异</a>》<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/02/study-technology-in-three-steps.html">https://program-think.blogspot.com/2009/02/study-technology-in-three-steps.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/03/80-20-principle-2-management-overview.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>无处不在的二八原理[2]：在管理方面的应用 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">无处不在的二八原理[2]：在管理方面的应用</a></h1>
-<div class="post-info"><span class="date-header">2009-03-01</span><a href="../../tags/E7AEA1E79086.html" class="tag">管理</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;前两周由于聊了“<a href="../../2009/02/daily-build-0-overview.html">每日构建</a>”系列和“<a href="../../2009/02/cxx-object-destroy-overview.html">C++对象之死</a>”系列，把二八原理系列给搁置了一些时间。今天终于又回到这个系列上了。我估计列位看官中，可能有不少人打算将来往管理方向发展，所以在聊完“<a href="../../2009/02/80-20-principle-1-software-developing.html">二八原理在软件开发的应用</a>”之后，咱们就来聊聊管理方面的话题。<a name='more'></a><!--program-think--><br />&#12288;&#12288;如果你已经在管理岗位上干活，希望后面的帖子能够对你有帮助；如果你尚未担任管理职能，但是将来有这方面的打算，也可以先大概了解一下。事先声明：管理方面帖子聊的内容只是我个人的经验，仅供大伙儿参考 <b>:-)</b><br /><br />&#12288;&#12288;在开始讲后续的“人员招聘”、“员工激励”等内容之前，先得说一下“三种人”的问题。由于列位看官大都在IT圈内混，所以今天我们就拿软件业来说事。但要记住，三种人的划分其实也适用于其它行业。<br />&#12288;&#12288;按照<a href="../../2009/02/80-20-principle-0-overview.html">二八原理</a>，优秀的员工在整个行业中大约占5%-20%；同理，糟糕的员工也大约占类似的比例。剩下那60%-90%的员工，我们称之为平庸的员工（说好听点叫普通的员工）。熟悉数学的同学可能会想到这类似于正态分布。为了形象点，找了一张正态分布图来比划一下（见下图，绿色表示优秀员工、红色是糟糕员工）。<br /><center><img src="../../images/2009/03/WpMsKB6-qiViFcb8PW3amYSCgpA-QfnUnklH29G4bK5Gp1p1Nayt4GhYIS584dvJu6kHAGBJu81z1X5TKUT8AkQO5IAPfu1MLzO5SWPV4i_3XFNajCGByieknB_j4J65eEolbzkY" alt="不见图、请翻墙" /></center><br />&#12288;&#12288;关于优秀的程序员有什么特点，在以前的帖子“<a href="../../2009/01/0.html">怎样才算是优秀开发人员</a>”里已经描述过了，这里就不再啰嗦。<br />&#12288;&#12288;至于什么是糟糕的程序员，我给出几个特征，大伙儿自个琢磨一下，身边有没有这样的人。<br />◇不诚信<br />◇老油条（包括没责任心、没工作热情、混日子等）<br />◇拒绝学习者（具体特征详见“<a href="../../2009/01/2.html#active">关于自学能力</a>”）<br />◇【低级】Bug大户（80%的低级Bug出自少数糟糕的程序员）<br /><br />&#12288;&#12288;另外，有些糟糕员工还有一种很要命的传染性，会导致周围的平庸员工向糟糕员工转化。我猜测古人所说的“一粒老鼠屎”，大概说的就是这种现象吧。<br />&#12288;&#12288;扣除优秀的和糟糕的，剩下就是平庸的。平庸的程序员一般都循规蹈矩，既没有特别突出的贡献，也不会犯什么严重的过失。所以平庸的员工属于“沉默的大多数”，一般不引人注意。<br /><br />&#12288;&#12288;有同学要问了：讲管理怎么扯到“三种人的划分”上去捏？其实“三种人的划分”是非常重要的。由于管理工作的本质属于和人打交道的范畴。当你搞明白三种人的划分并且知道你周围哪些人属于哪种类型，你就可以在管理的各个方面充分发挥优秀员工的积极因素、充分消除糟糕员工的消极因素。<br />&#12288;&#12288;三种人的问题搞明白之后，咱们该来讲讲具体的操作层面的话题了。由于和管理相关的内容有不少，估计一个帖子又写不下了。只好重构一把，拆分为几个帖子。初步考虑分为如下几个方面来聊：<br /><a href="../../2009/03/80-20-principle-3-management-hire.html">关于人员招聘（如何找到优秀的开发人才）</a><br /><a href="../../2009/03/80-20-principle-4-management-encourage.html">关于员工激励（如何发挥员工积极性）</a><br />关于......<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/03/80-20-principle-2-management-overview.html">https://program-think.blogspot.com/2009/03/80-20-principle-2-management-overview.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/03/80-20-principle-3-management-hire.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>无处不在的二八原理[3]：关于招聘（如何找到优秀的软件开发人才） - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">无处不在的二八原理[3]：关于招聘（如何找到优秀的软件开发人才）</a></h1>
-<div class="post-info"><span class="date-header">2009-03-02</span><a href="../../tags/E7AEA1E79086.html" class="tag">管理</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;今天咱们先来聊聊招聘的话题。为啥要先聊招聘捏？因为招聘工作是其它各项管理工作的源头（先得有人可管才能谈管理嘛）。并且招聘工作有其特殊性：招聘方面的失误传递到了后续的环节，其影响会成倍放大。这个现象非常类似于软件开发流程：如果需求阶段出了问题，该问题到设计阶段会放大十倍（设计人员会骂娘），到编码阶段会放大百倍（程序员会抓狂），到测试阶段......<br />&#12288;&#12288;费了这许多口水之后，大伙儿应该看出招聘工作的重要性了吧？既然知道了重要性，下面俺就来个现身说法，讲一下当初搭建开发团队的经验。<a name='more'></a><!--program-think--><br /><br /><br /><h2>★先确定比例</h2><br />&#12288;&#12288;在<a href="../../2009/03/80-20-principle-2-management-overview.html">上一个帖子</a>里，咱们已经介绍了优秀员工的稀缺性（只占 5%~20%）。所以你不要指望团队里所有人都是优秀员工，这不现实（尤其在咱们天朝）。如果你有这种企图，那你就会陷入完美主义的焦油坑。<br />&#12288;&#12288;另一方面，如果整个团队中优秀员工的比例太低（甚至趋向于0），那也非常棘手。这样的团队效率会很差，基本上干不了太多实事。而且要改良这样的团队，难度也是大大滴。<br />&#12288;&#12288;所以，根据俺个人的经验，让团队中优秀人员的比例略高于业界平均水平是比较合适的（大概在1/5到1/3）。只要保证大约这个比例的人是优秀的就差不多了。<br /><br /><br /><h2>★再确定顺序</h2><br />&#12288;&#12288;比例确定好了，后面就是招聘顺序的问题。一定要先把优秀的人搞到手，再去招平庸的人。【<b>这个顺序很重要</b>】。因为先进入团队的优秀人员会在团队中形成一个良好的氛围（包括思考模式、沟通效率、学习气氛、编码风格等）。这样就有利于影响后进入的普通开发人员并使其融入其中。久而久之，就可能形成良性循环。<br />&#12288;&#12288;以盖房子来打个比方（俺对盖楼不熟，说错了别丢臭鸡蛋）：盖房子要先把钢筋水泥框架搭好，后面再来沿着框架砌墙。只要水泥框架做的尺寸不差，那么砌墙也错不到哪儿去；反之，如果框架搭歪了（甚至搭错了），墙就很难砌好，房子也就成危房了。<br />&#12288;&#12288;从这个例子可以看出：团队中的优秀人员就相当于团队栋梁。一定要先搞定栋梁，后面的事情就好办多了。<br /><br /><br /><h2>★如何找到优秀人才（不太合适的途径）</h2><br />&#12288;&#12288;既然顺序也确定了，接下来就是动手找人了。由于优秀开发人员比较稀缺，所以【不能】纯粹依赖传统的招聘方式（到招聘网站登广告）。当然，不排除传统方式也能找到优秀人才，但是效率挺低的（个人感觉，简历中不到 1% 能算是优秀）。所以俺一般用传统方式来招【平庸】程序员。<br />&#12288;&#12288;可能有同学会说：“费什么劲啊？直接找猎头公司不就得了。”确实，通过猎头能够比招聘网站更有效地找到一些优秀的人才。不过猎头公司找来的人有一个缺点：由于这些人已经在猎头的档案库挂了号，所以将来猎头可能会经常来找他/她怂恿跳槽（人家猎头就是靠这个吃饭的），导致这些人的稳定性下降。当然啦，如果你很有把握留住优秀人才，那也就无所谓了。<br />&#12288;&#12288;另外，上述两种方式还有一个共同的不足：对应聘人缺乏了解。一般只能通过简历、面试、笔试这几招来探探底细。但是，大凡准备简历和面试的人，无不把自己包装得很光鲜，个个看上去都很完美的样子。至于笔试，俺觉得笔试考察人的角度难以做到全面。因此笔试结果【或许】可以判定某人【不】合适，但【肯定】无法用来确保某人合适。“不了解应聘人”导致的最大风险在于：可能让糟糕员工（何谓“糟糕”见<a href="../../2009/03/80-20-principle-2-management-overview.html">上一个帖子</a>）混入团队中。<br /><br /><br /><h2>★如何找到优秀人才（比较高效率的方式）</h2><br />&#12288;&#12288;前面批判了传统模式的种种缺点，接下来就得说一下俺个人觉得比较有效的几种方式了。<br /><br /><h3>◇通过朋友/熟人介绍</h3><br />&#12288;&#12288;俺这里所说的“朋友/熟人”，是指你比较了解和【信任】的人，并且也是混迹在软件开发界的。因为开发人员一般都有自己的社交圈子，圈内的人互相都知根知底。所以，通过朋友介绍的话，就容易知道应聘人到底有几斤几两。<br />&#12288;&#12288;比如俺当初开始组建团队时，有两个骨干人员就是通过熟人推荐进来的。<br /><br /><h3>◇通过网上社区（比如：BBS、邮件列表、SNS）</h3><br />&#12288;&#12288;一些高质量的网上社区（比如：<a href="https://groups.google.com/group/pongba" target="_blank" rel="nofollow">TopLanguage 论坛</a>）会浓缩一些精英人才在其中。可以到这种地方观察一段时间，看看社区成员的发言，如果感觉某某人比较中意，就可以先用邮件私下沟通一把。假如谈下来情投意合，就可以直接拉过来入伙了。<br />&#12288;&#12288;俺以前有个同事，经常混迹于国外某 Linux 开发论坛，后来被一老外看上（那老外在找 kernel 程序员），然后去了某外企。<br /><br /><h3>◇通过挖墙角</h3><br />&#12288;&#12288;说实话，这招有点损，但仍不失为一个有效的办法。这个方法的针对性挺强，找来的人基本不会令人失望。<br />&#12288;&#12288;使用这个方法的难点在于要了解被挖角的人，明白他/她真正看重什么，然后再投其所好，才能见效。要知道不同的人看重的东西是不一样的（俺在<a href="../../2009/03/80-20-principle-4-management-encourage.html">后面的帖子</a>会具体说这个问题）。比如对于某些高端的人才，薪酬往往不是其【最】看重的，因为这种人不是很缺钱。<br />&#12288;&#12288;上述三种方式各有千秋，要视具体情况来灵活运用，效果才会好。<br /><br /><br />&#12288;&#12288;由于今天是结合二八原理来谈招聘问题，所以就不细谈招聘过程中的一些细节问题了（比如面试人的技巧、如何筛选简历等）。假如大伙儿有兴趣，以后咱再单独介绍一下。另外，专门写了一个帖子聊招聘的误区，大伙儿可以看“<a href="../../2009/04/defect-of-hire.html">这里</a>”。下一个帖子，咱们来聊一下<a href="../../2009/03/80-20-principle-4-management-encourage.html">关于员工激励的问题</a>。<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/03/80-20-principle-3-management-hire.html">https://program-think.blogspot.com/2009/03/80-20-principle-3-management-hire.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/03/80-20-principle-4-management-encourage.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>无处不在的二八原理[4]：关于激励（如何发挥员工积极性） - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">无处不在的二八原理[4]：关于激励（如何发挥员工积极性）</a></h1>
-<div class="post-info"><span class="date-header">2009-03-12</span><a href="../../tags/E7AEA1E79086.html" class="tag">管理</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;由于激励是除了招聘之外，又一个非常重要的管理环节。上次已经介绍了<a href="../../2009/03/80-20-principle-3-management-hire.html">把二八原理应用到招聘中</a>，今天就该说说和激励有关的话题。<a name='more'></a><!--program-think--><br /><br /><br /><h2>★激励的目的</h2><br />&#12288;&#12288;大伙儿应该知道：IT 相关的行业，大都属于知识密集型；行业中的员工，大都是纯脑力劳动者。对于这样的员工，他们的产出是无形的，因此就无法像传统的制造业那样进行“记件式”的考核。因此也就不容易衡量员工的绩效。<br />&#12288;&#12288;所以，在知识密集型的企业内，激励就显得非常重要。企业要通过激励手段，让员工觉得工作很爽、很 high，然后干活就会很主动、很自觉。有效的激励措施是双赢的，不但对企业有好处（提高了产出和效率），而且对员工也有好处（得到了所需要的东西，后面会说到）。<br /><br /><br /><h2>★激励的对象（应该激励哪些人）</h2><br />&#12288;&#12288;在搞清楚目的之后，接下来就要聊一下激励的对象了。了解激励的对象很重要。这就好比市场营销中的广告战，你必须让广告投放到有效的受众，才能产生效果。所以打广告前，先得进行广告受众细分，搞明白哪些是<b>有效</b>受众。同样的道理，进行激励工作之前，也要对员工进行细分。只有搞清楚谁是【有效的】激励对象，才不会瞎忙。<br />&#12288;&#12288;关于激励对象的分类，其实在<a href="../../2009/03/80-20-principle-2-management-overview.html">前面的帖子</a>里面已经介绍过了（也就是“三种人”的划分）。在这三种人当中，咱们应该把大部分（80% 左右）的激励放在优秀人员身上，小部分（20% 左右）用于平庸员工，效果才会最好（至于糟糕员工，就省省吧，别费神搞啥激励了）。因为优秀员工的平均产出比糟糕员工高很多，如果同样提升10%的士气，显然优秀员工增加的绝对值也会大很多。而且，要让糟糕员工提升士气，那可不是一件容易的事。<br />&#12288;&#12288;不过俺观察下来，发现很多管理岗位的同学却是反其道而行之，总是花很多力气妄图改变糟糕员工的状态，到头来效果往往不甚理想。俺猜测这有可能是受了学校老师的影响。记得以前在中小学的时候，老师们总是花很多精力在“差等生”身上。但是大伙儿要明白，公司和学校有一个本质的区别：公司是商业机构，以盈利为目的；而学校则不是。所以，有些学校的做事方式，在公司中是不宜使用的。<br /><br /><br /><h2>★激励的方法（应该选哪种激励方式）</h2><br />&#12288;&#12288;搞清楚激励的对象之后，接下来就该谈谈激励的方法了。激励的方法有很多种，在具体运用上，一定要【因人而异，投其所好】。这就好比不同的广告投放方式。你得先摸清楚广告受众经常接触什么媒体（比如电视、报纸、网络），然后在相应的媒体投放广告，才会有效果嘛。<br />&#12288;&#12288;话说回来，常用的激励方式，大致有：经济利益、名誉、成就感、尊重、权力、个人能力。这几种激励方式本身没有好坏之分，只有适用与否的区别。下面咱们就来具体介绍一下这几种方式。<br /><br /><h3>◇经济利益</h3><br />&#12288;&#12288;这个最好理解，说白了就是钱的问题。这个方式对大部分人都有一定效果，但是效果的好坏差别很大。有些人很看重钱，而另一些人却不太看重。<br />&#12288;&#12288;要了解某员工是否看重钱，相对比较容易。俺一般在面试新人时就可以看出来了。那些在面试中对薪水、福利、待遇打听特详细的家伙，多半比较看重经济利益。<br />&#12288;&#12288;使用这种激励方式的难点在于搞好平衡。假设有两个同样优秀的人，一个看重钱，另一个不看重。这时候，你不能让两人的经济利益相差太大��否则就会丧失公信力。<br /><br /><h3>◇名誉</h3><br />&#12288;&#12288;名誉的方式，具体操作就是授予员工某些荣誉头衔和称号，或者进行公开表扬。这个方式适用于虚荣心比较强的人。这种激励方式的关键在于<b>公开</b>，知道的人越多，被激励者越爽。<br />&#12288;&#12288;咋样才晓得某员工是否虚荣心较强捏？这就需要通过平时的观察才能发现。举个例子：虚荣心强的人，表现欲一般也比较强（但不绝对）。你就可以留意一下集体活动时，谁比较喜欢抛头露面、表现自己，基本就心里有数了。<br /><br /><h3>◇尊重</h3><br />&#12288;&#12288;这种方式也好理解，就是对某员工给予足够的尊重、器重、重视。这种方式对于自尊心很强的人，效果好。<br />&#12288;&#12288;自尊心强的人，其实也容易判断。平时沟通中，一不小心被人戳到自尊了，反应特强烈的，就属于此类。<br /><br /><h3>◇成就感</h3><br />&#12288;&#12288;成就感的方式，一般来说就是安排某人干有挑战性或者意义重大的工作。一旦能做成，他/她就能得到很大的满足感。<br />&#12288;&#12288;一般注重成就感的人，也会有一定的虚荣心，可以参见前面的方法来判断；当然也有少数注重成就感但不在意虚荣的人，这类人就比较难发现了（得靠观察其它细节来判断）。<br /><br /><h3>◇权力</h3><br />&#12288;&#12288;权力的方式，就是给予某人权力（一般是决策权）。这种方式对于权力欲望强的人，效果很好。<br />&#12288;&#12288;不过权力欲望强的人，一般不容易看出来。中国的传统文化讲究含蓄，想要权力的人，一般不会直接开口要（再说了，直接开口要，也未必能要到啊）。因此，权力欲望强的人，就经常会在暗地里使各种法子来达到目的。如果团队里面这种人多了，免不了就要勾心斗角一番。有点跑题了，打住。要看出这种人，你需要有较强的察言观色之本领，方可一窥究竟。这种本领属于“只可意会，不可言传”，大伙儿自个儿去“意会”吧 :)<br /><br /><h3>◇个人能力</h3><br />这种方式，就是给予某员工学习/锻炼的机会（比如培训），使其个人能力获得提升。这个方式对于爱学习、注重个人发展的家伙，效果较好。<br />比较爱学习的人是很容易看出来的。俺一般会在面试中，通过旁敲侧击，试探出面试的人是否属于此类型（具体如何试探，将来谈面试技巧的时候再聊）。<br /><br /><h2>★激励方式总结</h2><br />&#12288;&#12288;说到这里，几种常见的激励方式也聊得差不多了，俺稍微总结一下。对于上面提到的名誉、尊重、成就感（其实还有认同感、归属感......限于篇幅没提及）这几种方式，属于心理学层面的激励，相对来说激励成本较低。而且，大伙儿要记住：80% 左右的员工是偏感性的，心理学层面的激励对感性的人挺有效果。<br />&#12288;&#12288;另外，俺要提醒一下，用权力的方式来激励是有一定危险性的。一定要确保被授予权力的人确实有相应的【能力】，否则产生的后患就如滔滔江水，绵绵不绝。<br />&#12288;&#12288;对任何一个被激励员工，都需要把上述几种激励方式配合使用。要明确员工【最想要】的是什么，然后再决定哪种方式为主、那种方式为辅。<br /><br /><br />&#12288;&#12288;本系列下一个帖子，咱们来聊一下......呃，暂时还没想好 :-(<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/03/80-20-principle-4-management-encourage.html">https://program-think.blogspot.com/2009/03/80-20-principle-4-management-encourage.html</a>
-</div>
-</div>
-</body>
-</html>

安全培训/维基备份/软件/综合性资料/编程随想的博客/俺博客的“离线浏览页面”和“博客电子书制作脚本”/blog/html/2009/03/book-review-mythical-man-month.html DELETED Viewed

@@ -1,26 +0,0 @@
-<!DOCTYPE html>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="zh-CN">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Python script by program.think@gmail.com" />
-<meta name="provider" content="program-think.blogspot.com" />
-<link type="text/css" rel="stylesheet" href="../../css/program-think.css" />
-<title>书评：《人月神话》——不朽的软件工程名著 - 编程随想的博客</title>
-</head>
-<body>
-<div id="main" style="width:100%;">
-<h1><a href="../../index.html" title="回到首页">书评：《人月神话》——不朽的软件工程名著</a></h1>
-<div class="post-info"><span class="date-header">2009-03-09</span><a href="../../tags/E4B9A6E8AF842FE5BDB1E8AF84.html" class="tag">书评/影评</a> <a href="../../tags/E7BC96E7A88B.html" class="tag">编程</a> <a href="../../tags/E7BC96E7A88B.E8BDAFE4BBB6E5B7A5E7A88B.html" class="tag">编程.软件工程</a> </div>
-<hr/>
-<div class="post">
-&#12288;&#12288;已经有好几周没有写书评了，今天突然想起来要写一写。由于<a href="../../2009/01/cxx-coding-standards-101-rules.html">上次的书评</a>是关于 C++ 的，今天打算写写软件工程方面的。对于软件工程而言，我个人认为到目前为止，尚未有哪本书的影响力和深刻程度能够超越《人月神话》（全名是：The Mythical Man-Month——Essay on Software Engineering）。于是考虑来聊一下鼎鼎大名的《人月神话》。如果你已经熟读此书，并且自认为深刻掌握其精华，本帖子你就不必再看了。<a name='more'></a><!--program-think--><br /><br /><h2>★作者及写书的背景</h2><br />&#12288;&#12288;根据“<a href="../../2009/01/choose-it-book.html">如何选择 IT 书籍</a>”里面提到的经验，作者是书籍质量的一个主要保证。所以我先来八卦一下《人月神话》的作者：<a href="https://en.wikipedia.org/wiki/Fred_Brooks" target="_blank" rel="nofollow">Frederick Phillips Brooks</a>（以下简称 Brooks）。这位老兄最牛X的成就是在<b>60年代</b>（那时他才【29岁】）主持并完成了一个同样很牛X的<b>IBM 360</b>系统的开发。<br />&#12288;&#12288;<b>IBM 360</b>后来被誉为是人类从原子能时代进入信息时代的标志。该项目不光具有历史意义，而且在软件工程方面非常有代表性（因为其规模和复杂度）。为了给大伙儿加深印象，列举该项目的几个数据如下：<br />－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－<br />软件人员总数　　2000　　四十年后，微软的Windows 2003团队也就5000人<br />软件总费用　　　5亿$　　发明第一个原子弹的曼哈顿工程也不过才花20亿$<br />开发周期　　　　4年<br />－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－<br />&#12288;&#12288;注意，上述仅仅是软件方面的统计。<br /><br />&#12288;&#12288;最终，<b>IBM 360</b>项目并没有完成全部的预定目标，但是对于这个史无前例的项目，居然没有中途夭折，本身已经算是奇迹了。后来，Brooks 在1975年（距今已30多年）把他所写的一些软件工程方面的随笔（很多都与 IBM 的360项目有关）整理出版，也就是我们今天点评的《人月神话》。<br /><br /><br /><h2>★本书的结构</h2><br />&#12288;&#12288;前面已经说了，Brooks 当年是把他写过的一些随笔整理出书的，所以书中的各个章节相对来说比较独立。因此你不一定按照排版的顺序来阅读。比如俺每次重读这本书都只是挑选其中一两个章节来看。<br /><br /><br /><h2>★本书的看点</h2><br />&#12288;&#12288;虽然本书的每个章节都称得上是经典，但限于篇幅，只把俺印象最深刻的几章介绍一下。<br /><br /><h3>◇第2章 关于【人月】的误导性</h3><br />&#12288;&#12288;这是本书最有名气的章节。在本章，Brooks明确反对使用“人月”这个极具欺骗性的度量单位。因为“人月”这个称谓暗示着“人”和“月”是可以互换的。<br />&#12288;&#12288;即使到今天为止，还是有大量的编程人员、测试人员、项目经理和软件公司老板在【错误地】使用“人月”来衡量软件开发的工作量，实际上，当某人宣称某工作量是6个人月时，这句话本身是没有太大意义的。一般来说，1个人干6个月的工作，6个人在1个月内几乎很难完成。所以俺在沟通工作量时，都会明确地讲清楚，需要几个人干几个月。<br />&#12288;&#12288;另外，Brooks 根据人月的不可互换推导出一个怪论：<b>向进度落后的项目增加人手会导致项目更加落后</b>。这个怪论是如此出名，以至于后来被称为“<a href="https://en.wikipedia.org/wiki/Brooks%27_law" target="_blank" rel="nofollow">Brooks 法则</a>”。这个法则蛮有用滴，每当有上级领导企图通过增加人手来���进度时（往往在项目后期），俺都会搬出这个法则来拒绝这种企图。<br /><br /><h3>◇第3章 关于团队的组成</h3><br />&#12288;&#12288;为了解决前几章中提到的大型团队的种种困难，Brooks 提出了一种新的解决方案：把大型团队拆分为若干个类似于外科手术式的小团队。<br />&#12288;&#12288;每个小团队有一名主程序员（类似于主刀医生），所有的问题分解和功能定义都通过主程序员来完成，以此来降低沟通成本。并且，每个主程序员配备若干个平庸的人帮他/她打下手，也很符合现实情况（还记得“<a href="../../2009/03/80-20-principle-2-management-overview.html">二八原理系列</a>”中提到的优秀人员和平庸人员的比例吗？）。具体的角色职责我就不细说了，书上都有。<br /><br /><h3>◇第16、17章 关于【没有银弹】的真知灼见</h3><br />&#12288;&#12288;实际上第16章“没有银弹”的内容来自于作者在1986年作的报告，后来才加入书中。第17章“再论没有银弹”是20周年版加入的。<br />&#12288;&#12288;据作者在本书的“20周年纪念版”中宣称，“没有银弹”是引发最多争议的章节。不过我个人认为：虽然引发最多争议，但是这两章却是全书最重要、最深刻且最有价值的章节。即使你从事的工作和软件工程无关，你也应该认真阅读它。<br />&#12288;&#12288;Brooks 在第16章分析了软件开发的【根本性困难】（复杂性、非一致性、易变性和不可见性）和【次要性困难】。分析完根本性困难和次要性困难之后，作者断言：未来十年内，【不可能】有某种技术突破（银弹）能够彻底解决“根本性困难”，从而导致软件开发效率有<b>数量级</b>的提高。<br />&#12288;&#12288;现在，时间已经过去了远远不止十年。在“没有银弹”发表之后，软件界冒出了数不清的新玩意儿（比如面向对象、组件技术、设计模式、CMM、UML、敏捷开发、RAD、等等），很多新玩意儿的创造者都号称他们发明了银弹。但实际上没有哪个新技术能够经受住时间的考验并真正获得银弹的称号。<br /><br /><br /><h2>★俺的建议</h2><br />&#12288;&#12288;啰嗦了这么多，最后来说说俺的几点建议：<br />1. 如果你从来没有看过本书，那赶紧去找一本来，并全部读一遍（不一定要按顺序看）。<br />2. 如果你以前看的是老版本，那赶紧去找来新版（20周年纪念版），并重点看看增补的4个章节。<br />3. 如果你已经把新版全部看完，今后可以考虑定期（例如每隔一两年）再拿出来翻一翻。<br /><br />&#12288;&#12288;为了免去大伙儿买纸版书的开销和找电子书的麻烦，俺特地放上此书的电子版。有兴趣下载的同学，请猛击“<a href="https://github.com/programthink/books" target="_blank">俺收藏的电子书目录</a>”。<div class="blogger-post-footer">
-</div>
-<hr/>
-<div class="copyright">
-<h4>版权声明</h4>
-本博客所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者<a href="mailto:program.think@gmail.com">编程随想</a>和本文原始网址：<br>
-<a href="https://program-think.blogspot.com/2009/03/book-review-mythical-man-month.html">https://program-think.blogspot.com/2009/03/book-review-mythical-man-month.html</a>
-</div>
-</div>
-</body>
-</html>