本文是一个DIY小夜灯的简易文档，由于笔者水平有限，无法保证没有错误和疏漏，为了避免“碰瓷”，做出如下声明。

在实际操作中，依据此文而产生的任何问题(包括但不局限于财产损失，人身伤亡等)与笔者无关，笔者既不赔偿，也不负法律责任。

如果您已经阅读了本文的一部分或全部内容，则表明您同意了上面的这个声明。

-------------------------下面正文--------------------------

微小功率的LED用的最多的就是阻容降压，然后限流点亮串联的LED。由于简单的阻容降压先天低效，只好串联LED提升工作电压来尽可能的提高效率，但由于LED的分散性，质量不好的先坏，串联起来的寿命远远低于单个LED的平均寿命。元器件简单降低成本，寿命还不会太长，两点都符合厂家经营之道，因此，这种先天缺陷的设计就成了市场主流。

下图是某个品牌3W LED灯泡的电路，该电路负载部分是一个560欧电阻和5个LED串联，供电部分是阻容降压后桥式整流，电解电容滤波后得到大约18V的直流电， 220V侧通过大约57毫安的工作电流。算下来功率220 * 57 / 1000 = 12.54VA，灯泡标称3W，好到计量插座测得只有1W，功率因数只有可怜的0.08，这种垃圾货却符合某大国一级能耗标准[习惯就好，砖家们订立的脑残标准多了去了]。

市面上几乎所有的小功率LED灯泡全是按照这种阻容降压整流再点亮LED的原理制作的，当然，全是绿色节能的“典范”，符合某国一级能耗标准。市面上大部分小功率5V充电头的功率因数接近0.5，远超普通的小功率LED节能灯，用来DIY小功率LED灯再好不过，借着一堆认证的优势，轻松把那些品牌小功率LED灯全部踩在脚下。

考虑到长期通电，设计上需要尽可能降低损耗，测试过几个闲置的5V电源的损耗作为候选。这些电源每个上面都有一堆几乎相同的认证标识，但实测结果嘛就是另外一回事了... 值得一提的是这里计算损耗用伏安VA，而非业界流行的瓦W。其实小功率开关电源即使满负荷，功率因数也极少超过0.5，空载更是惨不忍住，很多国货不足0.1(甚至低到0.01)，不用瓦W计算怎么去遮丑低效的电路呢？商人都懂质量好未必收益好，无底线的虚假广告+软文宣传是赚钱的法宝，其实何止LED光源，这是时代的商业文化，起码这片土上如此。

适配器实拍[旁边是一个5毫米草帽LED焊了一个1K欧电阻和USB口连线]

5V适配器损耗实测，容易看出基本分两档，有些电源可真不敢恭维，功率低[没准还虚标]损耗还大。

理论上能耗等级越高越好，个别厂家乱标的当然也有，这里就不说是谁家了，没有标注等级的一般低于III级。

最终选用了淘汰的微软手机充电头5V供电[实际大于3V就行]，实测总输入功率0.056VA，即使功率因数1.0[实际远远达不到]，算下来1年消耗不足0.5度电。LED发光亮度跟月光接近，对我而言刚刚好。如果觉得光线还不够柔和，LED可以用保鲜膜包一下(或半透明热缩管封一下等措施)。5V电源负载率很低，LED耗电占总功率的15%左右，电源自身损耗占了大约85%。如果觉得光线太暗，可以适当减小电阻增加电流从而增加亮度，例如1K欧姆电阻改为680或470或330或220欧姆等。

原理就这么简单，如下图。

实测E文Windows，Edition: Windows 10 Pro, Version: 2H2 Build: 19042.572 上OK。实测虚拟机上Win7 Ultimate Sp1 64位上也OK。实测虚拟机上Windows XP Pro, Sp2 32位上编译能成功，但结果不可用。如果你仍在用Windows XP，没有必要继续浏览此文。

免费的SDK解析PDF文件可选的有Poppler, MuPDF, PDFium等，三者中最后一个Apache协议，最宽松，Bug也最少，是最佳之选，只可惜在土鳖国下载谷歌的东西很困难，github上有编译好的二进制，只不过内嵌签名，如果一般性质的使用，是个很好的选择[https://github.com/bblanchon/pdfium-binaries]。MuPDF要么购买要么AGPL协议，对于多数人不可用 [https://mupdf.com/downloads/index.html]。最后只剩下Poppler可选，尽管GPL协议，而且获取容易，进程间通信也可以商用。当然，如果学生练手，不用关心版权，任何一个都可用。

安装poppler最简单的办法就是通过msys2(可能cygwin也行)，先把msys2 [选64位] 装上，再把开发工具系列以及poppler的依赖(cairo, iconv, glib, boost, lcms2, zlib, png, tiff, jpeg等等很多)都装上，如果用QT也得装QT，用GTK就得装GTK。其实msys2里面就有poppler了(mingw编译的版本)，装上就行。但是如果需要特定环境使用，比如Visual Studio，或者觉得msys2里的poppler版本不好用[我测试觉得它不太好用]，那就得自己编译。安装msys2和开发环境的方法网上一搜一大堆，这里就不罗嗦了。

固然不排除有人勇气可嘉，想独立编译poppler试试，我不是在此泼冷水，poppler依赖几十个dll，把这些依赖找全自己独立编译的想法根本不现实，因为编译依赖时还需要一大堆别的依赖，由于网络原因很难都顺利下载下来，即使都下载下来，编译方法各式各样，有些用常规方法根本就编译不过。我曾经编译过Poppler 0.59版就用的这个套路，最后不得不修改了很多源代码才编译成功，得到一个可用的版本。想到编译的艰辛过程，poppler 0.59版我用了一年没升级...

装完了msys2把编译器MinGW和make(可能是mingw32-make)加到PATH路径里，一般是***/mingw64/bin

接下来把CMake装上，可在这里下载https://cmake.org/files/

把Poppler下载下来，地址https://poppler.freedesktop.org/ 注意别忘了字体，因此poppler-data也需要，在安装完poppler再装它

编译poppler可用Visual Studio或者mingw[前面msys2里装了]，前者需要vcpkg用power shell命令编译，由于有一堆依赖的库，vcpkg编译前需要逐个下载那些依赖再编译，这个套路理论上没问题，但实际操作起来很难成功，这跟前面想独立编译poppler的想法如出一辙，因为有些依赖的库太难下载[也许因为我这里网络太糟?]。配合msys2安装依赖，用mingw编译poppler要容易的太多。

较新的poppler只能编译64位版本可用，如果想编译32位poppler也能成功，但编译完没法在32位系统上用，因为依赖的库有些在32位系统下无法运行，即使在32位系统上编译出32位的poppler也用不了，我在虚拟机上测试过多次，这样看来，曾经流行但老旧的32位Windows Xp 上没法用poppler了，好在这年头用Xp的人很少。

下载poppler源码后解压(可用7-Zip)，然后打开cmake-gui选择源代码路径和存放的目标文件夹编译就行了。如果希望出现.lib别忘了勾选CMAKE_GNUtoMS选项，编译最好指定Release版，否则默认编译的Debug版体积巨大，安装路径里不能有空格，因为安装时需要ming32-make[有人见过mingw64-make吗？]，它不支持路径里有空格。如果硬件不是骨灰级，编译时可开启多任务，我用的电脑CPU是i7-8700，直接命令行mingw32-make –j12编译需要几分钟的样子

下面不要选Visual Studio ***，应该选MinGW Makefiles


需要哪些选项勾选上，Configure失败的回到前面msys2里装上再重来，这个过程可能需要往复多次。
编译前最好指定Release版，如果不用手工指定，会默认编译Debug版，那样编译出的dll体积巨大！

 


如果前面勾选了CMAKE_GNUtoMS，编译中还会用到Visual Studio，而且编译器版本不能太低。


编译完用命令装mingw32-make install，会装到前面指定的路径c:/poppler/vc下，接下来再安装poppler-data
套路一样，由于它不需要依赖，要容易很多。

由于我不用Visual Studio，因此CMAKE_GNUtoMS勾选后编译的结果在Visual Studio下是否能用不知道，不过
不勾选该项时用MinGW编译的版本是没有任何问题的，我用poppler解析PDF文件做比对工具就用上述方法编译的。

http://www.cppblog.com/Chipset/archive/2020/10/23/217487.html

背单词：http://www.cppblog.com/Chipset/archive/2021/08/11/217696.html

友好提醒：别盲目跟随，请量力而行。

实用至上，可能只适合小众[适合大众的只能培育搬砖工]，相信大部分人士没必要在此浪费时间，实用至上比高分至上困难很多倍，打算看下去就提前做好心理准备吧。

现实中很多人学了十几年英语，面对老外时还会紧张，大部分人士听不懂老外说什么，更谈不上随意交流。多数反映是，好不容易捕捉到少数几个词，还在那冥思苦想的时候，老外都说了很大一段统统错过了... 如果能听懂，就算说的慢，老外也会等你，如果压根就听不懂，根本没法交流。举个现实点的例子吧，多数跨国公司待遇福利都不错，也没有那么多的潜规则，不过招聘新人时除了笔试之外往往还要面试，看重能力，是骡子是马出来溜溜呗...说来也怪，很多把“女人当男人用, 男人当畜生用”的企业却往往更看重学校牌子和等级证书...

废话少絮，步入正题。我们布边本上完全取消了音标，词汇表就是英对汉，专家们说应该自然拼读。人家英语母语的娃书上还有音标呢，却让二外的娃们玩自然拼读。既然觉得自然拼读这么好，为何不把小学语文上拼音全去掉推行自然拼读呢？这个果度很多事看破不能说破...

Reach E

Wonders G2

没音标就没音标，大不了去补习班学，这是过去，现在补习班也禁掉了。这下好，吃瓜一族们自己看着办吧...有钱的破费一点一对一外教？地下补习班？其实认可放养和补习班一族的人士没有必要看本文[也没必要看我写的每一篇娃学英语的文]。如果腰包紧张，可以看看下面的路数，可不保证一定适合你家娃...

上小学前，从26个字母开始，然后是音标，元音变化比较大，辅音容易拼一些。下面例子的地址用浏览器里打开就能听到或者看到了，耐心点，外网可能很慢 [资源全部取自公网，如果发现侵权则删除]

英语字母歌 https://1drv.ms/v/s!Al6txEwD06L5gVjDDH1k7YAs1zC_?e=wEhJpY
元音音标 https://1drv.ms/v/s!Al6txEwD06L5gVAdj15-J-rXUS0E?e=zJVvbz
辅音音标 https://1drv.ms/v/s!Al6txEwD06L5gVR4c4eD9yAveFK5?e=5jkqiu

实际操作起来尽量灵活一些，不要长时间对着屏幕，否则可能严重影响视力，可以买张挂图什么的贴墙上，为了学某个音标，至少学2-3个相应的单词，否则不容易记忆。一旦学会了基本的音标，再训练一些词和句的拼读，学会自己查词典，对于国内的娃，小学前能达到这程度就不错了。接下来就是长句和段落，信息时代，各种资源很多，充分利用呗。如果不知道从哪里起步，可以试试Backpack随书碟片放电脑上播放，按题目要求对着电脑听说。对应的Workbook每个单元有3个听力题目，可以事先把录音文件拷贝到手机里播放，让娃边听边做题目。Backback 是针对二外的，文章很短，我猜大多数娃学听录音和回答问题没啥压力，限于版权，这里不提供例子。值得一提的是，训练听说的教材有很多[视频音频也很多]，Backpack配套练习算是比较弱的。

本文例子里有的字幕个别单词拼写错误，拼读也偶尔有不对的。固然，这也没啥大不了的，我们平时用汉语也存在类似情况。

下面提供一个简单对话的例子，和一个很简单的故事 三只小猪，这个难度算基础吧。

日常对话 https://1drv.ms/v/s!Al6txEwD06L5gV6yn4kaMSZFEeyH?e=zVn11i
简单故事 https://1drv.ms/v/s!Al6txEwD06L5gWQ_cVUIJWz1SWyk

这里提一下口音问题，曾经烂大街的广告宣传“纯正的xx英语”就是纯正的智商税。以汉语为例，都说普通话，一个人分别来自北京，上海，广州，湖南，四川，陕西，之间交流不会有太大问题，尽管互相听着别扭。英语也是一样，更何况来自不同的国家。下面的自我介绍分别有美国人，英国人，加拿大人，澳大利亚人，新西兰人，各自口音有差异，几乎不影响理解，其实受过高等教育的德国人(二外)，甚至非洲某个英国殖民地国家的人都讲英语，一般都能听懂！

自我介绍 https://1drv.ms/v/s!Al6txEwD06L5gWHU17Hg9uYyAwDF?e=CRdH8n

听说中免不了词汇和语法，下面举例，专有词汇和习惯用语需要积累。

词汇 https://1drv.ms/v/s!Al6txEwD06L5gWLJKYq4CUD18TRo?e=6E2dB3

学习语法和词汇仅靠听说积累不现实，需要学短文。学完全文后还要复述(recall或retell)，也有的文章训练拼读(Read aloud)。不要觉得这很低效，没有老外天天陪同的环境，这可能是训练说最好的办法[其实用Reach和Wonders教材的米帝娃天天英语环境也是这么训练的]。这是一个循序渐进训练听说的过程，需要一番苦练，就算娃再聪明绝顶，时间上也得用月来算。

下面有几个(小学5年级课文)录音的例子，文章相对比较长。”给娃选教材“里有课文内容。

Wonders G5读写教程选文A Fresh Idea https://1drv.ms/u/s!Al6txEwD06L5gVOKucx3dKssp3zX?e=EEHdbh
Reach F上选文Coyote and Badger https://1drv.ms/u/s!Al6txEwD06L5gVJubdtC4dlqLVjt?e=glGj4S
Wonders G5文学欣赏选文Weslandia https://1drv.ms/u/s!Al6txEwD06L5gVGqcl5gTFr49o7Y?e=mhyc7i

值得一提的是，前面既然用教材(例如Backpack，Wonders等)，就应该和其他方面(读懂课文，了解语法和词汇等)一起结合起来系统化的学习，不要仅仅训练听说。

以上课文有点长，不过语速慢，可分段分章节训练，一般娃应该压力不大。一旦轻车熟路了(也可以不必等到这个时候)，就可以试着干点别的了，例如听歌、看电影等，不过这种提升听力的方法不是很见效，除非不介意反复听，下面继续举例。

歌曲 How Far I'll Go https://1drv.ms/u/s!Al6txEwD06L5gVrNTPEDZ7QVpl1d?e=y3V2We
卡拉OK https://1drv.ms/v/s!Al6txEwD06L5gWBD0XG4WwxvvKrD?e=YGiWji
为了激发学习兴趣，对于先天有点音乐细胞的娃，可以鼓励会唱1~2首歌曲[卡拉OK半轴乐网上有的是]。

还有故事，听完看完不能嘻嘻哈哈完事，对于喜欢的故事到达能讲给别人听的程度(例如 先汉语再逐渐过渡到英语，简单故事逐渐过度到长故事)，下面举例。

故事1 https://1drv.ms/v/s!Al6txEwD06L5gVnr_70m6OD-h7SI?e=u5kFXg
故事2 https://1drv.ms/v/s!Al6txEwD06L5gWWP_Yaun3j7S_GT?e=7X0isg

以上例子很简单，现实中的E文电影要难一些，因为口音和俚语多且杂，例如 Puss in Boots, Frozen, Big Hero 6, Zootopia, Moana, Jungle Book, Boss Baby...

等以上感觉良好了，可以试试实际应用，估计对多数人来说还会有些难度，其实又是一个新的适应过程而已。

科普文 https://1drv.ms/v/s!Al6txEwD06L5gVvt3_AorDnQVUDA?e=MZonLC

如果实际应用这种难度(例如听广告)也毫无压力了，那就跟一般英美的娃区别不大了...

就算平时看电影、会议、日常交流等都没任何压力了，但是还有听不懂的时候，这种场合也许有人偶尔会遇到，比如在某大学听某个口音很重的教授讲某天书一样的理论，别说留学的二外的一族，就算那些英语母语的听众，也是听得云里雾里一知半解...

一句话：听说就是训练熟练程度。多锻炼娃自己动手和动嘴或者说主动学习。还有，学课文也好、听歌也好、看电影也好，不能嘻嘻哈哈完事，什么东西都需要量化，该复述的复述，该拼读的拼读，该讲大意的讲大意，该背诵的背诵，除了听说还能学一些词汇和短语。一次学会一点压力很小，慢慢积累日久天长见分晓，如果执行力差，再好的方法也没用。

朱丽安娜科普克(出生于1954年10月10日)，婚后名字朱丽安娜迪拉，是一个德国-秘鲁哺乳动物学家。她是1971年兰萨508航班空难的唯一幸存者，空难发生后独自一人在亚马逊热带雨林生活了11天。他从3000米(9843英尺)坠落，落地时仍然被安全带捆在座椅上。

事前

朱丽安娜于1954年出生于秘鲁利马，父母都是在利马自然历史博物馆工作的德国人。她是生物学家汉斯威廉科普克和鸟类学家玛丽亚科普克的唯一孩子。在朱丽安娜14岁时，其父母带她去亚马逊雨林建造研究基地--潘古那。在这里她成了一个“丛林孩子”，学了野外生存技能。教育当局不同意这样做，要求朱莉安娜回到利马亚历山大冯洪堡德意志学校参加考试。她于1971年12月23日在此校毕业。

空难

朱丽安娜科普克在经历磨难上有双重生存故事可供讲述。在1971年圣诞节前夕，朱丽安娜搭乘了兰萨508航班。那时她刚从高中毕业，她的母亲玛丽亚本打算在1971年12月19-20日带着女儿去潘古那，但是朱丽安娜希望能在12月23日去利马参加毕业典礼。玛丽亚同意，打算圣诞节前夕再飞往潘古那，可是除了里尼思君特欧航空(兰萨)还有空余其余所有航班的席位均已售罄。尽管丈夫汉斯威廉强烈要求妻子不要乘坐那家航空公司的航班，因为该航空公司早已臭名昭著，但最终她们还是预定了机票。飞机起飞不久遭遇闪电，在空中开始解体并一头冲向地面。朱丽安娜发现自己一直被捆在座椅上，下落将近2英里最终落入秘鲁热带雨林。

在朱丽安娜科普克的此次事件上，专家指出由于在下降中她被安放到座椅上才导致她活了下来，只是断了锁骨而已。她是该航班的唯一幸存者，顺着溪流在雨林里生活了11天。

在她醒过来后丛林里的昆虫不再叮咬她，可是蛆已经感染了她的胳膊，9天后，她找到了一处露营地。在此，她给自己进行了初级治疗，例如用汽油浇到蛆感染的部位。蛆害怕汽油就离开了伤口。几个小时候后，运木工人发现了她，给与基本医疗并把她带到更宜居的区域，然后她被空运到医院。

伤口恢复后，朱丽安娜帮助搜救队定位失事地点和搜救死难者尸体。她妈妈的尸体于1972年1月12日被发现。朱丽安娜回到德国后伤口完全恢复了正常。跟父母类似，朱丽安娜获得生物学学位后返回秘鲁继续深入研究蝙蝠。她的双重生存故事成了书和电影的主体，其中包括了她的自传和他传，“当我从天而降”，以及导演沃纳赫尔佐格的纪录片“翅膀上的希望”。他(沃纳赫尔佐格)在1971年也预定了她(朱丽安娜)的那次航班，飞机起飞前最后一分钟改变计划，从而躲过一劫。

事后

朱丽安娜的侥幸存活成了各种瞎猜推断的主题。"很明显她被安全带捆在座椅上有了某种程度的盾牌和缓冲，而且理论上外围整排的座椅，就是朱丽安娜两边的那些，起到了降落伞的作用，减缓了她下落的速度..."。“风暴漂移以及落地点厚厚的枝叶可以进一步降低里冲击力...”。

朱丽安娜回到德国彻底康复过来，走了父母一样的路，在基尔大学学习生物，1980年毕业。在慕尼黑麦克西米兰大学获得博士学位后返回到秘鲁展开哺乳动物研究，专注于蝙蝠，在1987年发表论文，“秘鲁热带雨林里一个蝙蝠生物王国的研究”。1989年朱莉安娜科普克和一个专注于研究寄生黄蜂的昆虫学家艾力克迪拉结婚。2000年朱丽安娜接管了潘古那当上了主任，父亲去世了。

现在朱丽安娜迪拉在慕尼黑巴伐利亚动物学蒐藏研究中心当管理员。她的自传和他传”当我从天而降”(德语: Als ich vom Himmel fie)于2011年3月10日由派珀林格出版，为此她获得了2011柯琳文学奖。2019年秘鲁政府授予她高级军官的杰出服务奖。

给娃选教材：http://www.cppblog.com/Chipset/archive/2021/08/11/217695.html

显然英语只靠单词是不行的，但是没有单词是万万不行的。先看看我们学“会”了多少单词。义乌叫玉小学布鞭本英语1年级上册大约100词，下册约70，以后一直在70附近徘徊，直到小学毕业。如此算下来整个小学阶段满打满算总计也没有1K词。至于初中和高中，就不必统计了。其实大学英语教程四册全加来的词汇也不足3K(约2.8K)，而大缸要求，CET4的词汇约4K，CET6约6K，TEM8约9K-10K。过来人自然明白，根本远远不需那么多，过级照样妥妥的。

急功近利的文化被各类国人用得恰到好处，应试教育时代里学生们当然也不会例外。学霸们舍得卖力，拿本红宝书(或蓝宝书或者绿皮书或白皮书)的词典狂背，目的性很强，容易达到考试目标。问题是人生不能时刻准备着考试吧，考试过后半年单词还剩多少？一个受过高等教育的老外词汇量25-30K左右[网测]，汉语常用字词远远没那么多，计算机算法领域有个词叫哈希冲突，英汉释义背词大法注定对付标准化考试刚好，也只能到此刚刚好。

既然看到了问题症结，那总得解决吧。前面提到了阅读，考虑到时间原因，应该靠精读积累词汇，好的文章在搞懂细节的基础上背下来可能是最佳方式[语境很重要]，一举消灭拼读、单词、语法，用法，还能提升写作能力。由于基础词在不同文章里经常出现，经常阅读不同题材文章就等同于自动筛选出高频词并强化了记忆。基础词汇积累起来了，就转用英英词典，跟英汉对照的红宝书(蓝宝书、绿皮书、白皮书等等)彻底拜拜，阅读中故事情节的引力会促使小朋友进入良性循环。

Stride is an important concept in digital image processing. It allows performing several operations with an image in a very fast manner (in constant time) by simple modification of image metadata. If you are interested in finding out what stride is and how to use it stick with us.

Pixel representation in a computer memory

Before we dive into the concept of stride we first need to revise how digital images are stored in a computer memory. We will start from a pixel.

An image pixel is represented in a computer memory by a fixed number of bits. Typical pixel bit depth (amount of bits per pixel) is 32, 16, 8 or, for binary images, 1 bit. In typical RGB images, 8 bits are often used to store the color value ​​of a single channel. Thus, the total bit depth of one pixel is 24. Processing 32 and 16-bit chunks of data is simple and effective on a typical 32 and 64-bit processors. Therefore, the pixels are stored in the format of 32 bits, where the older (or younger, depending on the implementation) 8 bits remain unused. Such an approach to storing pixels requires more memory, but it allows speeding up image processing by using the standard size of the machine word. Thus, a standard RGB image occupies 32 bits in memory and has a depth of 24 bits. We will call another 8 bits necessary to supplement the size of the memory occupied by a pixel to the value of a multiple of degree 2, pixel padding. The total number of bytes occupied by a pixel in memory is called pixel stride (See Image 1).

Image representation in a computer memory

Images are stored in computer memory pixel-by-pixel, line by line. The upper left corner of the image is usually chosen as a coordinate origin (the upper left pixel of the image has the index [0, 0]). The image is stored in memory as a one-dimensional array. Pixels of the first line of the image are first written to the memory, then pixels of the second line and so on up to the last line. Each line in addition to the pixel bytes may also contain additional bytes — line padding. Additional bytes usually do not contain useful information and do not affect the visualization of an image when, for example, displayed on the screen. These additional bytes serve to complement a line, which is necessary for more efficient image processing and is caused by the specificity of the hardware used. For example, Cairo (a popular open source vector graphics software library) requires alignment of rows to multiple 4 bytes, which allows for more efficient image processing algorithms using vectorized processor operations and processing several image pixels simultaneously.

Introducing the term of line padding requires to introduce another closely coupled term — line stride.

Line stride (increment, pitch or step size) is the number of bytes that one needs to add to the address in the first pixel of a row in order to go to the address of the first pixel of the next row. It is important to note that an image width is measured in pixels and describes an image itself (and doesn’t depend on how an image is stored in a computer memory). In contrast, a line stride depends on how an image is represented in memory and is measured in bytes.

In program source code, an image is usually represented by a data structure containing metadata (image width and height, line stride, number of channels, encoding type, etc.), as well as a pointer to the address of the first image pixel in memory (further we will refer to this address as data_begin). This information allows us to unambiguously read and decode an image from memory, as well as to perform a series of fast image operations by changing only a metadata associated with an image.

An image representation in a computer memory. Lines of an image are stored one by one in one-dimensional array.

Image operations:
Let’s summarize all the terms which we introduced to this moment:
pixel_address — a pixel address in memory
pixel depth —the number of bits per pixel (containing valuable information)
pixel_stride — the number of bytes occupied in memory by a pixel of an image
data_begin — the address of the first image pixel in memory
channels — the number of image channels (3 for an RGB-image)
channel_address — the address of a particular pixel channel in memory
height — the image height in pixels
width — the image width in pixels
line_stride — the number of bytes occupied in memory by a line of an image

Operations:

1.       Computing pixel address in memory

The equation relating pixel memory address to its coordinates [y, x] in the image coordinate system can be represented as:

pixel_address = data_begin + y * line_stride + x * pixel_stride, (1)
where data_begin — the address of the first image pixel in memory.

Equation (1) is used whenever you access an image in memory. In the rest of operations, presented in this post, we will only change a metadata associated with an image and assume, that the equation (1) is applied after in order to access image.

2. Pixel decoding (for RGB image with an equal amount of bits per channel):

channel_address = pixel_address + n * depth / channels, (2)
where n is a channel index: n = 0, 1, …, channels — 1. Thus, for instance, for the typical RGB-image with an equal amount of bits per channel, a channel address in memory can be computed as follows:
R = pixel_address,
G = pixel_address + depth / channels,
B = pixel_address + 2 * depth / channels.

It is important to note that these equations depend on the type of the image stored. There are formats in which different number of bytes is used to store different channels.

3. Image flip

3.1 Vertical flip
data_begin = data_begin + (height- 1) * line_stride ,
line_stride = -line_stride.

Pointer to the first image pixel for the vertical flip

The negative line stride being inserted into equation (1) allows us to move upwards reading (or visualizing) an image from the last row to the first, thus, realizing vertical flip.

3.2 Horizontal flip
data_begin = data_begin + (width — 1) * pixel_stride ,
pixel_stride = -pixel_stride.

Pointer to the first image pixel for the horizontal flip

In the same manner as with negative line stride in the previous example, the negative pixel stride here allows us to move from right to left and to read (or visualize) an image flipped horizontally.

3.3 Vertical and horizontal flip
The combination of previous two approaches allows to flip an image in both directions at once:
data_begin = data_begin + (height-1) * line_stride + (width-1) * pixel_stride,
line_stride = -line_stride,
pixel_stride = -pixel_stride.

 
Pointer to the first image pixel for the simultaneous vertical and horizontal flip

4. Extracting image subwindow
data_begin = new_data_begin,
width = new_width,
height = new_height.
With this approach we set a new origin of our image (inside a boundary of the original image) and set a width and height which basically tell us how many time we should apply an equation (1) to read all pixels (width x height) and after which amount of pixels read we should increase the y coordinate (to start reading pixels of the next row). Note that such parameters as line stride remain unchanged.

5. Extracting single image channel
To extract a single image channel we can use a combination of equations (1) and (2):
pixel_address = data_begin + y * line_stride + x * pixel_stride + n * depth / channels,
where n — channel index, n = 0, 1, …, channels — 1.

REFERENCES
1.       A programmer’s view on digital images: the essentials: https://www.collabora.com/news-and-blog/blog/2016/02/16/a-programmers-view-on-digital-images-the-essentials/
2.      Microsoft Media Foundation Programming Guide: Image Stride:Image Stride When a video image is stored in memory, the memory buffer might contain extra padding bytes after each row of pixels…docs.microsoft.com
3.      Wikipedia: Stride of an array: https://en.wikipedia.org/wiki/Stride_of_an_array
4.      Cairo library: https://cairographics.org/

This is the C++11 template based header only library under Windows/Linux/MacOs to convert UFT-8/16/32 symbols and strings. The library transparently support wchar_t as UTF-16 for Windows and UTF-32 for Linux and MacOs.

UTF-8 and UTF-32 (UCS-32) both support 31 bit wide code points [0‥0x7FFFFFFF]with no restriction. UTF-16 supports only unicode code points [0‥0x10FFFF], where high [0xD800‥0xDBFF] and low [0xDC00‥0xDFFF] surrogate regions are prohibited.

The maximum UTF-16 symbol size is 2 words (4 bytes, both words should be in the surrogate region). UFT-32 (UCS-32) is always 1 word (4 bytes). UTF-8 has the maximum symbol size (see conversion table for details):

• 4 bytes for unicode code points
• 6 bytes for 31bit code points

UTF-16 surrogate decoder:

UTF-8 Conversion table

// यूनिकोड
    static char const u8s[] = "\xE0\xA4\xAF\xE0\xA5\x82\xE0\xA4\xA8\xE0\xA4\xBF\xE0\xA4\x95\xE0\xA5\x8B\xE0\xA4\xA1";
    using namespace ww898::utf;
    std::u16string u16;
    convz<utf_selector_t<decltype(*u8s)>, utf16>(u8s, std::back_inserter(u16));
    std::u32string u32;
    conv<utf16, utf_selector_t<decltype(u32)::value_type>>(u16.begin(), u16.end(), std::back_inserter(u32));
    std::vector<char> u8;
    convz<utf32, utf8>(u32.data(), std::back_inserter(u8));
    std::wstring uw;
    conv<utf8, utfw>(u8s, u8s + sizeof(u8s), std::back_inserter(uw));
    auto u8r = conv<char>(uw);
    auto u16r = conv<char16_t>(u16);
    auto uwr = convz<wchar_t>(u8s);

    auto u32r = conv<char32_t>(std::string_view(u8r.data(), u8r.size())); // C++17 only

    static_assert(std::is_same<utf_selector<decltype(*u8s)>, utf_selector<decltype(u8)::value_type>>::value, "Fail");
    static_assert(
        std::is_same<utf_selector_t<decltype(u16)::value_type>, utf_selector_t<decltype(uw)::value_type>>::value !=
        std::is_same<utf_selector_t<decltype(u32)::value_type>, utf_selector_t<decltype(uw)::value_type>>::value, "Fail");

A PDF describes the content and appearance of one or more pages. It also contains a definition of the physical size of those pages. That page size definition is not as straightforward as you might think. There can in fact be up to 5 different definitions in a PDF that relate to the size of its pages. These are called the boundary boxes or page boxes:

·         The MediaBox is used to specify the width and height of the page. For the average user, this probably equals the actual page size. For prepress use, this is not the case as we prefer our pages to be defined slightly oversized so that we can see the bleed (Images or other elements touching an outer edge of a printed page need to extend beyond the edge of the paper to compensate for inaccuracies in trimming the page), the crop marks and useful information such as the file name or the date and time when the file was created. This means that PDF files used in graphic arts usually have a MediaBox which is larger than the trimmed page size.

·         The CropBox defines the region that the PDF viewer application is expected to display or print. So if a PDF contains a CropBox definition, Acrobat uses it for screen display and printing. For prepress use, the CropBox is pretty irrelevant. The GWG industry association recommends not to use it at all.

·         The TrimBox defines the intended dimensions of the finished page. Contrary to the CropBox, the TrimBox is very important because it defines the actual page size that gets printed. The imposition programs and workflows that I know all use the TrimBox as the basis for positioning pages on a press sheet. By default the TrimBox equals the CropBox.

·         The BleedBox determines the region to which the page contents needs to be clipped when output in a production environment. Usually the BleedBox is 3 to 5 millimeters larger than the TrimBox. It is nice to know the size of the BleedBox but it isn’t that important in graphic arts. Most prepress systems allow you to define the amount of bleed yourself and ignore the BleedBox. By default the BleedBox equals the CropBox.

·         The ArtBox is a bit of a special case. It was originally added to indicate the area covered by the artwork of the page. It is never used for that but can be handy in a few cases:

·         On a PDF page that contains an advertisement, the ArtBox can be used to define the location of that ad. This allows you to place that PDF on another page but only use the area covered by the advert.

·         A more common use of the ArtBox is as a means to indicate the safety zone. When creating a poster that will be placed in a lightbox, the designer must make sure text and logo’s aren’t positioned too close to the edge. If the poster is not mounted properly, this could cause that text or logo to disappear behind the frame of the lightbox. In book design, there is also a margin where you cannot put text because the binding might make it difficult to read text that is too close to the spine. The area where it is safe to place graphic elements is called the safety zone or text safe area. The ArtBox can be used to indicate the dimensions of this part of the page.

General rules regarding page boxes

·         Each page in a PDF can have different sizes for the various page boxes.

·         The page boxes are always rectangular. That may seem logical but artwork is not always rectangular: a PDF can represent an oval label or the foldout of a cardboard box.

·         A PDF always has a MediaBox definition. All the other page boxes do not necessarily have to be present in regular PDF files.

·         The above rule is not true for the PDF/X file formats:

·         PDF/X-1a and PDF/X-3 compliant files need to include the MediaBox, TrimBox, and BleedBox.

·         PDF/X-4 files need, next to the MediaBox, a TrimBox or an ArtBox, but not both. The ArtBox or TrimBox cannot be larger that the BleedBox. If a CropBox is present, the ArtBox,  TrimBox, and BleedBox need to extend beyond its boundaries.

·         The MediaBox is the largest page box in a PDF. The other page boxes can equal the size of the MediaBox but they are not expected to be larger (The latter is explicitly required in the PDF/X-4 requirements). If they are larger, the PDF viewer will use the values of the MediaBox.

BBox

Within PDF files there is another box, the bounding box or BBox, that is used. The bounding box is a rectangular frame that determines the dimensions of an object (such as a graphic, font or pattern) that is placed inside a PDF document. As such, this box has nothing to do with the page boxes.

对于所有编程学习者，尤其是零基础的同学们，在学习的初期，一定要给自己做一个思想上的转变。在我的编程学习理论中，这个思想的转变至关重要，什么时候你把这个思维转换过来了，你就是真正上道的那一天。

这个思维转换就是：不要把自己当学生，而是要把自己当开发者。

不同的身份认同感，最后会导致不同的行为模式，而这行为模式，会对你的编程学习造成非常大的影响。

区别一：记笔记 VS 写技术文章

学生有一个特点，就是他们喜欢记笔记，但是开发者不怎么记笔记，而是会把自己学会的东西写成技术文章、教程的形式发表在技术博客或者知乎等网站上。

一个很有名的学习法叫做费曼学习法，这个学习方法简单地说，就是在学完一个东西之后，去给别人讲明白，注意，是讲给别人听，当你写成文章发表在网上的时候，你自然会去用更通俗的语言，更清晰的逻辑去讲述这个事物背后的逻辑，这个过程，是对自己学习的一个检验，也是加深映像，整理思路的重要过程。

那么如果你是去记笔记的话，很有可能，你不会去试图讲清楚这个东西，而是倾向于去照抄，或是不完全照抄，以“提纲”或是“知识点”的形式抄在本子上，说句实话，照抄的笔记，真的没用，因为现在搜索引擎的能力已经可以让你把大多数东西快速找到，你为什么还要照抄到笔记本上呢？

从功利的角度考虑，技术文章的写作，别人可以直接访问，也可以逐渐累积你的影响力，一个好的个人技术博客，会给你的简历加分很多，而一个厚厚的笔记本，没有人会管你记了什么。

区别二：以学会XX为目标 VS 以做出XX为目标

你会发现，学生思维里面有一个重要的特点，就是他们总是特别关注自己“学会了什么”，不仅如此，他给自己定的目标，定的计划，永远都是”学会XX书第XX章内容“。

学生永远在准备, 而开发者早已动手。

如果你还在上学，学生思维是“这个学期我要学会XX课程”，而开发者思维是“这个学期我要做出XX”。

如果学Python，学生思维会拿起一本教材，开始从头到尾看，我不知道你们发现没有，几乎所有那种编程语言教材，长得都差不多，上来先是基本的语法，基本的整型变量，浮点型变量之类的，然后伴随着几个小的教学例子。

开发者学Python，他第一步绝对不是去书店买教材，而是先去了解，Python适合做什么，然后他了解到，Python适合做爬虫，数据分析，AI，还能很轻松地搭建Web后端，之后他逛了一下午Github，看了看那些Python高星项目都是做啥的，于是他给自己定下了这个目标：半年时间内，我要用Python和Python周边的库搭建出一个网站，这个网站服务端运用爬虫技术爬取一些数据，可以提供知乎粉丝性别比例分析功能。

学生继续看书，一个个的知识点去记忆，拿着他的小本本去总结知识点，而开发者上官网简单的看了下Reference Doc的简单交互式语法教程后，便马上开始了边做边学的过程，有了一个实际的项目目标，朝着这个目标走，不断地发现自己不会这，不会那，然后有目的性的去补足知识，他了解到了beautiful soup作为爬虫主库，flask作为后端web服务主库，然后会去看一些简单的教程，在这个过程中，基础语法得到了熟练，也训练了工程能力。

学生的成就感来源于学会了什么，开发者的成就感来源于做出来什么。

开发者很功利，他们深知他们学会的所有东西都是为了开发出伟大的产品而服务的，所以他们绝对不会出现“在学一个东西，但是也不知道学这个用来干嘛”的窘境。

区别三：厌恶不确定性 VS 接受不确定性

学生们总是对“确定性”有一种几乎疯狂的追求，他们总问，“C语言学到什么程度就一定能被大厂录取？”，“掌握XX要几个月？”，“上课认真听讲，认真做笔记，考试是否一定能上80分？”

这种对确定性的追求，直接导致学生有一种下意识的举动：

干什么都等准备好了再去做，但是却“永远在准备”。

因为他们害怕那种不太会还要硬上带来的各种不确定性，他们渴求一种内功的修炼，寄希望于”把基础夯实了，就能顺畅的开发，所以还是先夯实基础吧！”

开发者选择接受这种不确定性，他们愿意”边学变做“，因为他们知道，最初学习敲键盘的时候，他们就是这么做的，边看某个按键在哪，边打字，做和学交叉进行，他们始终抱有疑问，他们又始终试图通过学习的延伸拓展去解决疑问，他们仿佛就像是拿着烛火在迷宫中行走的侠客，在游戏的一开始，对迷宫的结构一无所知，通过不断地摸索和碰壁，逐渐建立起对整个地图的认知.

区别四: 线性学习 VS 递归学习

学生喜欢线性的学习，因为线性的学习（拿本教材从头到尾慢慢看）正是符合了他们对确定性的追求，可惜这违背了学习的本来面目

开发者知道，人脑最不擅长的就是线性枚举，即便我们认识几千个汉字，但是我们无法去线性地去将所有认识的汉字枚举出来，我们的大脑，本就不是用来进行线性思考的，而复杂度上了一定程度的知识，线性的掌握，基本不可能。

有难度的知识，往往是这样的：为了搞懂A，而去学B，为了学会B，而去学C，这叫递归学习，递归虽深，但有回溯，它最终会回溯到我们的起点。

所以开发者的学习更偏向于递归式的学习，而且可能会以一个知识点为起点，去完成树状知识外围的遍历。（有点像搜索引擎去爬虫）

知识是树状结构, 或者网状结构.

当我们试图遍历一个树的时候, 最简单直接的方式就是递归, 如果你非要去"线性"的学, 那就你是把编程学习当成了链表, 还是“单向”的，这种算法怎么可能用来遍历树呢？

区别五：拿会XX定义自己 VS 拿XX项目作者定义自己

linus 从来不说自己精通 c 语言, 与其说他不需要, 不如说他不关心, 因为他是 linux 和 git 的作者.

linus 这个程序员之神就是一个典型的开发者思维的人.

我希望所有计算机专业的同学们, 等你们毕业了之后, 你的github应该是绿油油的, 而不是贫瘠的一片白.

我希望你们用你们的简历里写的是"用c语言实现了一个XX引擎, github链接”http://github.com/xxxxxx”而不是"精通c".

我希望学生们明白, 任何一个像样子的项目, 制作周期至少是按月计, 你的大学有四年时间, 哪怕一个项目做一年, 你也能拿出两三个好项目, 不一定有多少star, 但是要完整, 文档, 测试, 一应俱全.

我希望学生们知道, 做项目和写课后习题不一样, 课后习题一个小时, 而项目是长期不断努力, 不断学习突破的过程, 需要你每天都搞, 善始善终, 最终拿出成果来.

我希望学生们明白, 这个世界衡量一个人的成就, 从来都是"他做了什么", 而不是"他学会了什么", 不要总用修炼内功去感动自己, 必要时, 也请你为开源世界贡献一点自己的力量.

我希望学生们明白, 考上985, 拿奖学金, 这都不叫成就, 因为和别人没关系, 只有真正影响到别人的东西, 让这个世界变得更好的东西, 才是值得去"秀"的.

最后送给学生们一句话: 愿你早日忘记学生的身份, 以开发者的姿态, 面对这个世界。

https://solarsystem.nasa.gov/moons/jupiter-moons/io/overview/

Introduction

Jupiter's rocky moon Io is the most volcanically active world in the solar system, with hundreds of volcanoes, some erupting lava fountains dozens of miles (or kilometers) high. Io’s remarkable activity is the result of a tug-of-war between Jupiter's powerful gravity and smaller but precisely timed pulls from two neighboring moons that orbit farther from Jupiter – Europa and Ganymede.

In mythology, Io is a mortal woman transformed into a cow during a dispute between the Greek god Zeus – Jupiter in Roman mythology – and his wife, Hera – Juno to the Romans.

概要

木星的卫星艾奥是太阳系里火山活动最强烈的一个世界，有几百座火山，有些火山喷发熔岩喷泉高达几打英里(几十千米)。艾奥异常的行为是木星强大的引力和两个较小卫星之间精确定时拉锯的结果，这两颗卫星轨道距离木星较远，分别是欧罗巴和伽倪墨得斯。

在古神话里，艾奥是个女凡人被变成了牛，原因是古希腊天神宙斯--罗马神话里是朱庇特(译注:木星的音译)--和他的妻子赫拉之间产生了矛盾--罗马人称朱诺。

Size and Distance

A bit larger than Earth's Moon, Io is the third largest of Jupiter's moons, and the fifth one in distance from the planet.

大小和远近

比地球的卫星月亮稍大，是木星的第三大卫星，距地球远近上位列第五。

Orbit and Rotation

Although Io always points the same side toward Jupiter in its orbit around the giant planet, the large moons Europa and Ganymede perturb Io's orbit into an irregularly elliptical one. Thus, in its widely varying distances from Jupiter, Io is subjected to tremendous tidal forces.

These forces cause Io's surface to bulge up and down (or in and out) by as much as 330 feet (100 meters). Compare these tides on Io's solid surface to the tides on Earth's oceans. On Earth, in the place where tides are highest, the difference between low and high tides is only 60 feet (18 meters), and this is for water, not solid ground.

Io's orbit, keeping it at more or less a cozy 262,000 miles (422,000 kilometers) from Jupiter, cuts across the planet's powerful magnetic lines of force, thus turning Io into a electric generator. Io can develop 400,000 volts across itself and create an electric current of 3 million amperes. This current takes the path of least resistance along Jupiter's magnetic field lines to the planet's surface, creating lightning in Jupiter's upper atmosphere.

轨道和旋转

尽管艾奥始终一面对着木星围绕这个巨大的行星旋转，但是较大的卫星欧罗巴和伽倪墨得斯干扰了艾奥的轨道导致形成了不规则的椭圆形。这样以来，在和木星广远的间距变换中，艾奥受到巨大的潮汐力。

这些力导致艾奥表面忽起忽落(或者进和出)高达330英尺(100米)。对比一下艾奥固态表面的潮汐和地球上海洋的潮汐。在地球上，最高潮汐的地方，高低潮落差不过60英尺(18米)，而且还是水，不是固态的陆地。

艾奥的轨道，使之处于或多或少距离木星262000英里(422000千米) 一个温馨距离，切割这个行星强大的磁力线[译注：木星的磁场是太阳系里最强的，比地球磁场强几十倍，形成原因目前不特别清楚]，致使艾奥成了一个发电机。艾奥自身能产生40万伏的电压，产生3百万安的电流。这些电流沿着木星磁力线流经木星低阻抗表面，在木星高层大气产生闪电。

Surface

The tidal forces generate a tremendous amount of heat within Io, keeping much of its subsurface crust in liquid form seeking any available escape route to the surface to relieve the pressure. Thus, the surface of Io is constantly renewing itself, filling in any impact craters with molten lava lakes and spreading smooth new floodplains of liquid rock. The composition of this material is not yet entirely clear, but theories suggest that it is largely molten sulfur and its compounds (which would account for the varied coloring) or silicate rock (which would better account for the apparent temperatures, which may be too hot to be sulfur). Sulfur dioxide is the primary constituent of a thin atmosphere on Io. It has no water to speak of, unlike the other, colder Galilean moons. Data from the Galileo spacecraft indicates that an iron core may form Io's center, thus giving Io its own magnetic field.

表面

潮汐力在艾奥内部产生巨大的热量，导致它表面下的地壳成为液态，寻找任何到达表面的逃离路径释放压力。这样以来，艾奥表面会得到持续的更新，用岩浆填充任何陨石坑而且会产生光滑的液态熔岩洪泛平原。地质具体成分不太清楚，但理论假说认为大部分是熔化的硫磺及其硫化物(较好的解释了表面不同的颜色构成)或硅酸盐石头(较好的解释了显而易见的表面温度，都硫磺就太热了)。艾奥稀薄的大气主要组分主要是二氧化硫。不得不说，艾奥表面没有水，不像其它较冷的伽利略卫星们[译注：最初古天文学家伽利略发现了一系列的木星卫星，所以后来就有了这种称呼]。伽利略太空船采集到的数据指出，艾奥中心可能存在铁核，于是就拥有了自己的磁场。

Potential for Life

Constant volcanism and intense radiation make Io an unlikely destination for life.

潜在生命

持续的火山活动和强烈的辐射使得艾奥不太可能成为生命的落脚点。

Magnetosphere

As Jupiter rotates, it takes its magnetic field around with it, sweeping past Io and stripping off about 1 ton (1,000 kilograms) of Io's material every second. This material becomes ionized in the magnetic field and forms a doughnut-shaped cloud of intense radiation referred to as a plasma torus. Some of the ions are pulled into Jupiter's atmosphere along the magnetic lines of force and create auroras in the planet's upper atmosphere. It is the ions escaping from this torus that inflate Jupiter's magnetosphere to over twice the size we would expect.

磁圈

伴随着木星自转，木星的磁场包围了艾奥，清扫艾奥，平均每秒从艾奥掠走大约1吨(1千千克)物质。这些物质在磁场里电离，形成面包圈状的离子云，具有强烈的辐射，称之为等离子圆环。一些离子沿着磁力线被拉入木星大气，在木星上空产生极光。这些逃离圆环的离子导致木星磁圈膨胀，比我们预期大小大了一倍不止。

Discovery

Io was discovered on Jan. 8, 1610 by Galileo Galilei. The discovery, along with three other Jovian moons, was the first time a moon was discovered orbiting a planet other than Earth. The discovery of the four Galilean satellites eventually led to the understanding that planets in our solar system orbit the Sun, instead of our solar system revolving around Earth. Galileo apparently had observed Io on Jan. 7, 1610, but had been unable to differentiate between Io and Europa until the next night.

Galileo originally called Jupiter's moons the Medicean planets, after the powerful Italian Medici family and referred to the individual moons numerically as I, II, III, and IV. Galileo's naming system would be used for a couple of centuries.

It wouldn't be until the mid-1800s that the names of the Galilean moons, Io, Europa, Ganymede, and Callisto, would be officially adopted, and only after it became apparent that naming moons by number would be very confusing as new additional moons were being discovered.

In mythology, Io is a mortal woman transformed into a cow during a marital dispute between the Greek god Zeus—Jupiter in Roman mythology—and his wife, Juno. NASA’s Juno mission is named in honor of Juno who could peer through the clouds and expose her husband’s wrongdoings. The spacecraft also peers through clouds to reveal Jupiter’s secrets.

发现史

艾奥在1610年元月8日被伽利略伽利雷发现。和其它三个木星的卫星一起被发现的，这是首次发现地球之外的行星拥有自己环绕的卫星。伽利略四卫星的发现最终导致人类认识到太阳系里的行星们围着太阳转，而不是太阳系围着地球转。伽利略显然于1610年元月7日就发现了艾奥，但是直到第二天晚上才能把它和欧罗巴区分开。

伽利略最初称木星的卫星为美第奇家族行星，意大利美第奇家族之后，这些独立的卫星才被命名为I, II, III和IV。伽利略命名的体系会被沿用几个世纪。

直到18世纪中期伽利略卫星的艾奥，卡利斯托，欧罗巴和伽倪墨得斯几个名字才被官方采纳，因为随着更多卫星被发现，原来以数字命名卫星的做法非常令人费解。

在古神话里，古希腊天神宙斯--罗马神话里称朱庇特--和他的妻子朱诺之间的一次婚姻矛盾导致凡人艾奥[译注：以汉语文化的视角来看，神仙宙斯有婚外情凡人艾奥]变成了牛。美国航空航天局的朱诺之旅为了向朱诺女神表达敬意特此命名，寓意是朱诺能看透云层揭露其丈夫的错误行为。该太空船也能透过云层去揭示木星的秘密。

安布雷拉公司[伞公司]的创始人，詹姆斯·马库斯博士有个女儿艾莉西亚正在早衰死亡。马库斯几乎绝望，把T病毒用于给女儿和患有该病的别人治疗。在对另一个孩子施用该病毒治疗后，患者死掉又活过来立即成了僵尸，马库斯为此企图关闭该流程。他的商业伙伴亚历山大·艾萨克斯命令阿尔伯特·威斯克处死了马斯克，自己收养了艾莉西亚并接管了该公司。

After the events in Washington D.C., Alice awakens after being betrayed by Wesker. The Red Queen appears and tells Alice she has 48 hours to infiltrate the Hive, over 400 miles west on I-64 in Raccoon City. The Umbrella Corporation has developed an airborne anti-virus, which can kill every organism infected by the T-virus, but is waiting for the last few remaining humans to be wiped out.

哥伦比亚特区华盛顿事件后，爱丽丝经历威斯克的背叛后苏醒过来。红后出现并告知爱丽丝，她必须在48小时内潜入浣熊市蜂巢，蜂巢位于向西400英里之外的浣熊市I-64区。安布雷拉公司已经开发出了能空气传播的抗病毒，会杀死所有感染了T病毒的生物，目前正等着最后遗留的少数人类被消灭。

Enroute to Raccoon City, Alice is captured by Isaacs, learning the "Isaacs" she previously killed was a clone. She escapes his convoy and reaches Raccoon City, where she is ambushed by a group of survivors: Doc, Abigail, Christian, Cobalt, Razor, and Claire Redfield, who survived the attack on Arcadia. Isaacs' convoy approaches, trailed by a horde of zombies. Alice and the group defeat the convoy, retrieve Isaacs' few human captives and burn the horde, though Cobalt is killed. Alice and crew enter the Hive entrance, at the bottom of the crater from the nuclear bomb previously dropped on the city. Wesker, in control of the Hive, releases mutated guard dogs, killing Christian and a freed captive.

在去往浣熊市的路上，爱丽丝被艾萨克斯俘虏，认识到她原来杀死的那个艾萨克斯其实是个克隆人。爱丽丝逃脱他的护卫队到达浣熊市后被一群幸存者伏击，这些幸存者有道克、艾比盖尔、克里斯托、克波特、瑞泽、克莱尔·雷德菲尔德，他们是阿卡迪亚遭到攻击后的幸存者。艾萨克斯护卫队赶往这里，尾随了一大群僵尸。爱丽丝队伍击败了护卫队，收容了艾萨克斯的几个人类俘虏，焚毁了僵尸群，但克波特在战斗中丧生。爱丽丝队伍进入蜂巢入口，入口在之前浣熊市丢核弹炸的大坑底部。威斯克控制着蜂巢，释放了变异的警卫狗，杀死了克里斯托和一个自由了的俘虏。

The Red Queen appears to Alice and explains that her program is in conflict, as she can never hurt an Umbrella employee but also must value human life. She plays a video of Isaacs explaining to Umbrella's executives a plan to release the T-virus, cleansing the world of humanity; many of the rich and powerful, including the company executives, are stored in cryogenic capsules in the Hive, with the intention of rebuilding the world following the resulting apocalypse. The Red Queen warns Alice that someone in her group is helping Umbrella.

红后出现在爱丽丝面前，解释她的程序有冲突，因为她不能伤害安布雷拉雇员而且还要衡量人类生命。红后播放了一个影碟，艾萨克斯正给安布雷拉公司管理层解释他的计划，释放T病毒清理人类世界，很多富人和当权者包括公司管理者，用低温荚膜封藏在蜂巢里，毁灭世界后再重建。红后警告爱丽丝，她的队伍里有人正在帮助爱布雷拉公司。

The group encounters several traps, killing Abigail and Razor. Alice and Doc plant bombs throughout the Hive, from the leftover equipment of the original team to investigate the Hive. Alice confronts the real, tech-upgraded, Isaacs. Doc is revealed to be Umbrella's spy, and Claire is captured by Wesker. A cryogenic capsule opens, releasing Alicia Marcus, Umbrella's co-owner, and Marcus' daughter. Isaacs reveals to Alice that she is actually a clone of Alicia, before going on to explain his plan to eliminate the pair and assume control of Umbrella. Alicia fires Wesker, allowing the Red Queen to crush his legs with a security door. Doc tries to shoot Alice, but his gun is empty — as Alice had earlier deduced his treachery — and Claire executes him. After giving Wesker a deadman's switch to the primed bombs, Alice and Claire pursue Isaacs while Alicia uploads a copy of her childhood memories.
这群人遭遇了几个陷阱，艾比盖尔和瑞泽丧生。爱丽丝和道克在整个蜂巢部署了炸弹，从原队伍的遗留设备处一直到勘察蜂巢沿路[译注：原文有错误]。爱丽丝面对真实有技术装备的艾萨克斯。道克被暴出是安布雷拉安插[在幸存者中]的间谍，克莱尔也被威斯克抓住。一个低温荚膜打开，艾丽西亚·马库斯 出现，她是公司的合伙持有人，詹姆斯·马库斯的女儿。艾萨克斯首先揭示爱丽丝是艾莉西亚的克隆人，然后解释他计划除掉合伙人艾莉西亚完全掌控爱布雷拉。艾莉西亚煽动威斯克，让红后关闭安全门夹断他的腿。道克向爱丽丝开枪，但没有子弹--爱丽丝之前推断出他是叛徒--克莱尔击毙了道克。塞给威斯克一个死人开关[译注：不按着蜂巢就炸]后，爱丽丝和克莱尔追杀艾萨克斯，此刻艾莉西亚上传她童年记忆的拷贝。

Isaacs, Alice and Claire fight; Isaacs overpowers Claire and attacks Alice in the Laser Corridor, eventually defeating her, but she uses that moment to activate a grenade in his pocket. She escapes to the surface with the anti-virus, but Isaacs reboots and catches her before she can release it. Before he can kill her, the Isaacs clone (from the convoy) arrives and kills him, believing itself to be the original Isaacs, but the clone is then devoured by the undead. Alice releases the anti-virus, killing all of the undead around her before she passes out. Wesker simultaneously drops the deadman's switch, destroying himself, Alicia, the Hive, and the hibernating Umbrella elite.

艾萨克斯对抗爱丽丝和克莱尔，艾萨克斯战胜克莱尔，并在激光走廊里攻击爱丽丝最终获胜，但爱丽丝利用该时机触发了他口袋里的手雷。爱丽丝带着抗病毒逃到地面，但艾萨克斯复活并在爱丽丝投放抗病毒前抓住了她。在艾萨克斯杀死爱丽丝前，艾萨克斯的克隆人(来自护卫队)赶到，杀死了艾莎克斯，觉得自己才是真正的艾萨克斯，但克隆人又被僵尸吞没。爱丽丝释放了抗病毒，她倒下前杀死了她周围所有的僵尸。此刻，威斯克丢下了死人开关，毁掉了自己，艾莉西亚，蜂巢，休眠中的安布雷拉精英们。

Claire wakes Alice, who survived because the anti-virus killed only the T-virus within her body, not the healthy cells. The Red Queen uploads Alicia's childhood memories into Alice, granting her a childhood. Alice travels into Manhattan, saying that the anti-virus, carried only by the winds, will take years to reach all corners of the globe, and until it does, her mission is not finished.

克莱尔唤醒了爱丽丝，爱丽丝活了下来，因为抗病毒只杀死她体内的T病毒，而非健康细胞。红后给爱丽丝加载了艾莉西亚所有的童年记忆，给她赋予了童年。爱丽丝去曼哈顿旅行，[故事]声称抗病毒被风吹到世界各角落需要多年，在此结果前，爱丽丝的任务还没结束。

Architectures

Please send updates/corrections to predef-contribute.

Alpha

Example

AMD64

Notice that x32 can be detected by checking if the CPU uses the ILP32 data model.

ARM

Example

ARM64

Blackfin

Convex

Example

Epiphany

HP/PA RISC

See also OpenPA.net.

Example

Intel x86

Notice that Watcom C/C++ defines _M_IX86 for both 16-bits and 32-bits architectures. Use __386__ or _M_I386 to detect 32-bits architectures in this case.

Notice that the Stratus VOS is big-endian on IA32, so these macros cannot be used to detect endianness if __VOS__ is set.

Example

Intel Itanium (IA-64)

Example

Motorola 68k

Example

MIPS

Example

PowerPC

Example

Pyramid 9810

RS/6000

SPARC

Example

SuperH

SystemZ

TMS320

Example

TMS470

Gerard J. Holzmann

NASA/JPL Laboratory for Reliable Software

Pasadena, CA 91109

Most serious software development projects use coding guidelines. These guidelines are meant to state what the ground rules are for the software to be written: how it should be structured and which language features should and should not be used. Curiously, there is little consensus on what a good coding standard is. Among the many that have been written there are remarkable few patterns to discern, except that each new document tends to be longer than the one before it. The result is that most existing guidelines contain well over a hundred rules, sometimes with questionable justification. Some rules, especially those that try to stipulate the use of white-space in programs, may have been introduced by personal preference; others are meant to prevent very specific and unlikely types of error from earlier coding efforts within the same organization. Not surprisingly, the existing coding guidelines tend to have little effect on what developers actually do when they write code. The most dooming aspect of many of the guidelines is that they rarely allow for comprehensive tool-based compliance checks. Tool-based checks are important, since it is often infeasible to manually review the hundreds of thousands of lines of code that are written for larger applications.

The benefit of existing coding guidelines is therefore often small, even for critical applications. A verifiable set of well-chosen coding rules could, however, make critical software components more thoroughly analyzable, for properties that go beyond compliance with the set of rules itself. To be effective, though, the set of rules has to be small, and must be clear enough that it can easily be understood and remembered. The rules will have to be specific enough that they can be checked mechanically. To put an easy upper-bound on the number of rules for an effective guideline, I will argue that we can get significant benefit by restricting to no more than ten rules. Such a small set, of course, cannot be all-encompassing, but it can give us a foothold to achieve measurable effects on software reliability and verifiability. To support strong checking, the rules are somewhat strict – one might even say Draconian. The trade-off, though, should be clear. When it really counts, especially in the development of safety critical code, it may be worth going the extra mile and living within stricter limits than may be desirable. In return, we should be able to demonstrate more convincingly that critical software will work as intended.

Ten Rules for Safety Critical Coding

The choice of language for a safety critical code is in itself a key consideration, but we will not debate it much here. At many organizations, JPL included, critical code is written in C. With its long history, there is extensive tool support for this language, including strong source code analyzers, logic model extractors, metrics tools, debuggers, test support tools, and a choice of mature, stable compilers. For this reason, C is also the target of the majority of coding guidelines that have been developed. For fairly pragmatic reasons, then, our coding rules primarily target C and attempt to optimize our ability to more thoroughly check the reliability of critical applications written in C.

The following rules may provide benefit, especially if the low number means that developers will actually adhere to them. Each rule is followed with a brief rationale for its inclusion.

1. Rule: Restrict all code to very simple control flow constructs – do not use goto statements, setjmp or longjmp constructs, and direct or indirect recursion.

Rationale: Simpler control flow translates into stronger capabilities for verification and often results in improved code clarity. The banishment of recursion is perhaps the biggest surprise here. Without recursion, though, we are guaranteed to have an acyclic function call graph, which can be exploited by code analyzers, and can directly help to prove that all executions that should be bounded are in fact bounded.

(Note that this rule does not require that all functions have a single point of return – although this often also simplifies control flow. There are enough cases, though, where an early error return is the simpler solution.)

2. Rule: All loops must have a fixed upper-bound. It must be trivially possible for a checking tool to prove statically that a preset upper-bound on the number of iterations of a loop cannot be exceeded. If the loop-bound cannot be proven statically, the rule is considered violated.

Rationale: The absence of recursion and the presence of loop bounds prevents runaway code. This rule does not, of course, apply to iterations that are meant to be non-terminating (e.g., in a process scheduler). In those special cases, the reverse rule is applied: it should be statically provable that the iteration cannot terminate.

One way to support the rule is to add an explicit upper-bound to all loops that have a variable number of iterations (e.g., code that traverses a linked list). When the upper- bound is exceeded an assertion failure is triggered, and the function containing the failing iteration returns an error. (See Rule 5 about the use of assertions.)

3. Rule: Do not use dynamic memory allocation after initialization.

Rationale: This rule is common for safety critical software and appears in most coding guidelines. The reason is simple: memory allocators, such as malloc, and garbage collectors often have unpredictable behavior that can significantly impact performance. A notable class of coding errors also stems from mishandling of memory allocation and free routines: forgetting to free memory or continuing to use memory after it was freed, attempting to allocate more memory than physically available, overstepping boundaries on allocated memory, etc. Forcing all applications to live within a fixed, pre-allocated, area of memory can eliminate many of theseproblems and make it easier to verify memory use. Note that the only way to dynamically claim memory in the absence of memory allocation from the heap is to use stack memory. In the absence of recursion (Rule 1), an upper-bound on the use of stack memory can derived statically, thus making it possible to prove that an application will always live within its pre-allocated memory means.

4. Rule: No function should be longer than what can be printed on a single sheet of paper in a standard reference format with one line per statement and one line per declaration. Typically, this means no more than about 60 lines of code per function.

Rationale: Each function should be a logical unit in the code that is understandable and verifiable as a unit. It is much harder to understand a logical unit that spans multiple screens on a computer display or multiple pages when printed. Excessively long functions are often a sign of poorly structured code.

5. Rule: The assertion density of the code should average to a minimum of two assertions per function. Assertions are used to check for anomalous conditions that should never happen in real-life executions. Assertions must always be side-effect free and should be defined as Boolean tests. When an assertion fails, an explicit recovery action must be taken, e.g., by returning an error condition to the caller of the function that executes the failing assertion. Any assertion for which a static checking tool can prove that it can never fail or never hold violates this rule. (I.e., it is not possible to satisfy the rule by adding unhelpful “assert(true)” statements.)

Rationale: Statistics for industrial coding efforts indicate that unit tests often find at least one defect per 10 to 100 lines of code written. The odds of intercepting defects increase with assertion density. Use of assertions is often also recommended as part of a strong defensive coding strategy. Assertions can be used to verify pre- and post-conditions of functions, parameter values, return values of functions, and loop-invariants. Because assertions are side-effect free, they can be selectively disabled after testing in performance-critical code.

A typical use of an assertion would be as follows:

if (!c_assert(p >= 0) == true) {

     return ERROR;

}

with the assertion defined as follows:

#define c_assert(e)    ((e) ? (true) : \

                                       tst_debugging(”%s,%d: assertion ’%s’ failed\n”, \

                                       __FILE__, __LINE__, #e), false)

In this definition, __FILE__ and __LINE__ are predefined by the macro preprocessor to produce the filename and line-number of the failing assertion. The syntax #e turns the assertion condition e into a string that is printed as part of the error message. In code destined for an embedded processor there is of course no place to print the error message itself – in that case, the call to tst_debugging is turned into a no-op, andthe assertion turns into a pure Boolean test that enables error recovery from anomolous behavior.

6. Rule: Data objects must be declared at the smallest possible level of scope.

Rationale: This rule supports a basic principle of data-hiding. Clearly if an object is not in scope, its value cannot be referenced or corrupted. Similarly, if an erroneous value of an object has to be diagnosed, the fewer the number of statements where the value could have been assigned; the easier it is to diagnose the problem. The rule discourages the re-use of variables for multiple, incompatible purposes, which can complicate fault diagnosis.

7. Rule: The return value of non-void functions must be checked by each calling function, and the validity of parameters must be checked inside each function.

Rationale: This is possibly the most frequently violated rule, and therefore somewhat more suspect as a general rule. In its strictest form, this rule means that even the return value ofprintf statements and file close statements must be checked. One can make a case, though, that if the response to an error would rightfully be no different than the response to success, there is little point in explicitly checking a return value.

This is often the case with calls toprintf and close. In cases like these, it can be acceptable to explicitly cast the function return value to (void) – thereby indicating that the programmer explicitly and not accidentally decides to ignore a return value. In more dubious cases, a comment should be present to explain why a return value is irrelevant. In most cases, though, the return value of a function should not be ignored, especially if error return values must be propagated up the function call chain.

Standard libraries famously violate this rule with potentially grave consequences. See, for instance, what happens if you accidentally execute strlen(0), or strcat(s1, s2, -1) with the standard C string library – it is not pretty. By keeping the general rule, we make sure that exceptions must be justified, with mechanical checkers flagging violations. Often, it will be easier to comply with the rule than to explain why non- compliance might be acceptable.

8. Rule:   The use of the preprocessor must be limited to the inclusion of header files and simple macro definitions. Token pasting, variable argument lists (ellipses), and recursive macro calls are not allowed. All macros must expand into complete syntactic units. The use of conditional compilation directives is often also dubious, but cannot always be avoided. This means that there should rarely be justification for more than one or two conditional compilation directives even in large software development efforts, beyond the standard boilerplate that avoids multiple inclusion of the same header file. Each such use should be flagged by a tool-based checker and justified in the code.

Rationale: The C preprocessor is a powerful obfuscation tool that can destroy code clarity and befuddle many text based checkers. The effect of constructs in unrestricted preprocessor code can be extremely hard to decipher, even with a formal languagedefinition in hand. In a new implementation of the C preprocessor, developers often have to resort to using earlier implementations as the referee for interpreting complex defining language in the C standard. The rationale for the caution against conditional compilation is equally important. Note that with just ten conditional compilation directives, there could be up to 210 possible versions of the code, each of which would have to be tested– causing a huge increase in the required test effort.

9. Rule: The use of pointers should be restricted. Specifically, no more than one level of dereferencing is allowed. Pointer dereference operations may not be hidden in macro definitions or inside typedef declarations. Function pointers are not permitted.

Rationale: Pointers are easily misused, even by experienced programmers. They can make it hard to follow or analyze the flow of data in a program, especially by tool-based static analyzers. Function pointers, similarly, can seriously restrict the types of checks that can be performed by static analyzers and should only be used if there is a strong justification for their use, and ideally alternate means are provided to assist tool-based checkers determine flow of control and function call hierarchies. For instance, if function pointers are used, it can become impossible for a tool to prove absence of recursion, so alternate guarantees would have to be provided to make up for this loss in analytical capabilities.

10. Rule: All code must be compiled, from the first day of development, with all compiler warnings enabled at the compiler’s most pedantic setting. All code must compile with these setting without any warnings. All code must be checked daily with at least one, but preferably more than one, state-of-the-art static source code analyzer and should pass the analyses with zero warnings.

Rationale: There are several very effective static source code analyzers on the market today, and quite a few freeware tools as well.2 There simply is no excuse for any software development effort not to make use of this readily available technology. It should be considered routine practice, even for non-critical code development. The rule of zero warnings applies even in cases where the compiler or the static analyzer gives an erroneous warning: if the compiler or the static analyzer gets confused, the code causing the confusion should be rewritten so that it becomes more trivially valid. Many developers have been caught in the assumption that a warning was surely invalid, only to realize much later that the message was in fact valid for less obvious reasons. Static analyzers have somewhat of a bad reputation due to early predecessors, such as lint, that produced mostly invalid messages, but this is no longer the case. The best static analyzers today are fast, and they produce selective and accurate messages. Their use should not be negotiable at any serious software project.

The first two rules guarantee the creation of a clear and transparent control flow structure that is easier to build, test, and analyze. The absence of dynamic memory allocation, stipulated by the third rule, eliminates a class of problems related to the allocation and freeing of memory, the use of stray pointers, etc. The next few rules (4 to 7) are fairly broadly accepted as standards for good coding style. Some benefits of other coding styles that have been advanced for safety critical systems, e.g., the discipline of “design by contract” can partly be found in rules 5 to 7.

These ten rules are being used experimentally at JPL in the writing of mission critical software, with encouraging results. After overcoming a healthy initial reluctance to live within such strict confines, developers often find that compliance with the rules does tend to benefit code clarity, analyzability, and code safety. The rules lessen the burden on the developer and tester to establish key properties of the code (e.g., termination or boundedness, safe use of memory and stack, etc.) by other means. If the rules seem Draconian at first, bear in mind that they are meant to make it possible to check code where very literally your life may depend on its correctness: code that is used to control the airplane that you fly on, the nuclear power plant a few miles from where you live, or the spacecraft that carries astronauts into orbit. The rules act like the seat-belt in your car: initially they are perhaps a little uncomfortable, but after a while their use becomes second-nature and not using them becomes unimaginable.