标签: 编程语言

风马牛不相及？编程语言C | 指鹿为马

热度 3 kiwaho 2020-10-22 19:57

金秋十月，吹点科技浪漫主义的文学之风，以活跃科学网的气氛。 编程语言C，是美国计算机科学家Dennis Ritchie发明的，常用于底层代码编写，仅比汇编语言ASM略显高级一些。家喻户晓的微软Windows操作系统，最初就是用C语言编写的。 C语言码农们都知道，他们经常不得不“指鹿为马”。 这话怎讲？请看下面两行代码片段： double var = 1.0; printf(ASCII value of 2nd byte in memory= %c\\n, ( char *)var ); 咋的？明明是指向8字节长的浮点数，我偏偏要指鹿为马，说它是指向单字节流的指针，甚至可根据需要，随时随意cast成任何数据类型。 动机很简单，计算机的内存管理与数据结构很琐碎，用太高级的语言操作，真的很费机时，效率也低。 指针是C语言最核心的概念，内存寻址都要用到指针操作，CPU处理指针的算术偏移，效率比所有其它操作都高。 反正内存里都是数据，怎么解释怎么方便，是躺赢的不二法则。 另一厢，“指鹿为马”恰是中国古代的经典成语之一，乃心高气傲者的霸气侧漏；当权者最喜欢故意指鹿为马，常用于测试谁是忠心耿耿的追随者。 不服？ 放马过来，我把它当鹿打趴，哈哈！ 两厢都说清楚，大家就领悟了：“C语言”与“指鹿为马”，原来并不是那么风马牛不相及嘛！ 最后留道语文课后作业： 成语“风马牛不相及”的正解为何？ 欢迎有兴致者在评论区交作业。 参考文献： 1、 致敬先辈：伟大的C语言之父——丹尼斯·里奇 2、 指鹿为马的历史人物,指鹿为马故事主人公是谁? 3、 你知道“风马牛不相及”的“风”是什么意思吗？

7103 次阅读|5 个评论

邹晓辉讲授 人机交互认知系统：编程语言信息处理之比较（以Python为例）

geneculture 2020-9-19 09:46

今天上午10点30分开始讲授 人机交互认知系统：编程语言信息处理之比较（以Python为例）

个人分类: 双语信息处理|1240 次阅读|0 个评论

中国科技界是给西方人提供抢劫屠杀人类魔法跟战斗力最多的吗？

coltec11 2020-8-20 10:49

基本常识不搞懂，越勤劳给敌人提供的魔法就越多越强大，是在勤劳地自杀 社会机体如同人体，社会程序链网如同人体内的生化程序链网。 理想状态下，我们的中央神经，需要建立起各种感知控制机制 通过遍布全身的外周神经末梢 去对每个器官，细胞内的每个生化反应启动、过程、状态、结果进行精确感知描述 并在整体系统层面实现统一性，系统化的控制. 这些遍布社会机体各处，进行感知描述控制的外周神经末梢 应该直接与中央神经直接联系 若这些外周神经末梢与其他国家的中央神经进行连接 那这个社会机体就会出现精神分裂症状 社会器官，社会程序链网会出现严重的结构，功能缺陷 编程语言，编程平台，工具软件，工业软件是在现代技术条件下 我们用来描述，控制社会程序链网上能量，物资，信息，人员传递的”神经末梢” 若这些基本工具我们不国产化，而始终坚持市场主导元则 一定要使用西方十字军开发或者被其控制公司开发的软件 如同在告诉敌人我们的社会机体在做什么，怎么做 还为敌人提供后门，提供控制的窗口跟机会 这如同是在人类智商进化阶梯金字塔的顶层与底层之间 建立起不该建立的信息传递通道，给西方十字军提供抢劫屠杀全人类的魔法跟战斗力 我们国内的公司一旦开发出来什么新技术 西方十字军很快就会拿出相同或类似的技术来 包括超级计算机，量子计算机，核聚变这些决定人类未来 一旦它们掌握了这些技术，马上就会反咬中国，说中国盗窃了它们的技术 而我们国家这些靠着“会做人”会念几句“做人经”爬上去的“做人专家” 不但不解决这样的外周神经末梢与西方敌对国家中央神经相连的状态 还轻描淡写地叫我们“要自信”。。。。。 可这真的是个严重的结构功能缺陷问题， 再自信都是与自然界基本法、控制基本原理则相违背的 我们使用这些敌方编程语言，编程平台，工具软件，工业软件 使用得越勤奋，开发出来的新技术越多，很快就成为敌国中央神经内的智慧了 会成为西方十字军抢劫屠杀全人类，包括屠杀我们自己的魔法跟战斗力。 赶快让那些身居高职，智商低下得无法拿出任何解决现实问题方案的低智商做人专家滚蛋吧 中国要自救，就从这些外周神经末梢的自主化开始。

0 个评论

细思愈恐，使用西方编程语言及编程平台是否是在给西方提供魔法

coltec11 2020-7-28 10:46

我们使用任何西方编程语言及平台，编写的软件 如同在告诉对方，我们在做什么，怎么做 还给对方留下可能的后门，任其操控。 为此曾被骂的狗血淋头，被无数次踢出技术群，可我始终不渝的疑问 我们使用别人的编程语言、平台发展出来的任何先进技术 是否都是在给别人提供魔法跟战斗力？ 作为信息的基本常识或者说原理： 编程语言跟其他语言（语音、文字、图像、视频等）一样 就是用来做为与事物结构，过程，参数，相对应的“能量序列”. 语言 = 能量序列 =事物对象 + 运行过程 + 结构参数 + 过程参数 这些能量序列只要跟事物能做到一一对应，就可以对任何事物结构，过程，参数 做到精确的定点，定位，定轨迹，定量 也就是说，使用同样编程语言，只要一入网， 就能知道这些软件描述的事物结构，过程，参数是什么。 那么更进一步，使用C，C++，C#, JAVA，等任何西方人开发的编程语言，工具软件， 在所有工业，农业，军事国防，经济，教育，设计制造等行业开发出来的程序 是否都可以被放在一个跨越大时间，大空间，跨越各个行业领域的坐标系内 被定点，定位，定轨迹，从而还原出整个国家社会程序链网上 所有能量，物资，信息，人员，思维领域的设计意识形态结构的传递过程呢？ 这是个细思愈恐，让人毛骨悚然的问题 我们是否可以从硬件基础元件，晶体管动作的排列组合开始， 到汇编语言，到高级语言，到编程平台，工具软件， 做一套从头到尾，真正彻底的国产化？

73 次阅读|0 个评论

一个持续了50年还未纠正的“常凯申”式科技翻译错误

热度 3 leiyian 2018-12-4 09:45

大部分学过编程的人都编过汉诺塔程序，这是一个关于递归的编程范例。但是Tower of Hanoi中的Hanoi是越南首都河内。把河内翻译成汉诺跟把蒋介石翻译成常凯申是一样的，为什么这样一个错误几十年了还没有纠正？甚至很少人注意到？ 首先当然是计算机编程专家翻译的这个名称，最早的翻译出错误就不应该，翻译者应该查字典，而不是想当然音译。后面的编辑没有注意到也不应该，但是没有意识到这个问题也不奇怪。 但是有那么多人看这些书，肯定有人知道。为什么一直没有改？ 我在1995年注意到这个问题，上课的时候也讲过几次。我还知道另一个老师也知道这个错误。为什么写编程书的，还有那么多出版社编辑，一个都不知道？还是我们准备约定俗成装瞎到底？ 想象一下，“常凯申”流传了40年才被人指出翻译错了，这样一个社会是不是整体太愚昧了？不过这个时候，在这样的社会，可能大家不会怪翻译错了，而怪你指出的人多事找事吧（事情正在向这个方向发展）。 对于认为我多事的人，我有这么几个问题： 第一个翻译者知道Hanoi是河内吗？如果他知道，他会把Hanoi翻译成汉诺吗？70年代翻译教材的人会不知道河内吗？在70年代，在中国，河内可是比伦敦、东京还有名。 因为河内是一个外国首都名，所以如何翻译无所谓吗？中国人叫河内叫了多少年了？中国的出版标准是那么说的吗？ 第一个翻译是不是一个错误？错误持续下去就不是错误了吗？很多人在不知情的情况下接受了这个错误，错误就不是错误了？ 叫河内还是叫汉诺并不影响对概念的理解，这是编书者和编辑的工作标准吗？

个人分类: 个人看法|5006 次阅读|3 个评论

[转载]如何选择编程语言

dkwork 2016-3-5 17:29

科学网的图片限制宽度，分辨率太低，可点击下面链接获得全图。 http://blog-fungenomics-com.qiniudn.com/st.post.2015-01-22.ProgramToStart.png

个人分类: 计算机|954 次阅读|0 个评论

RedMonk 发布了一年两次的编程语言排行榜

热度 1 bigdataage 2015-10-13 19:52

RedMonk 发布了 2015 年 6 月的编程语言排行榜，JavaScript 居榜首，Go，Swift 继续上升，函数式编程语言 Scala，Haskell 和 Clojure 上升明显。 现在已经是 2015 的第三个季度了，RedMonk 发布了一年两次的编程语言排行榜，一如既往，跟 Drew Conway 和 John Myles White 在 2010 分析的过程 差不多，是根据编程语言在 GitHub 和 Stack Overflow 上讨论的多少和使用量来统计的，可以预测未来编程语言的发展趋势。 排名的根据是编程语言在 Stack Overflow 和 GitHub 都观察过，同时结合很多其他社区的分析统计，GitHub 主要是根据代码行数统计。 下图是 2015 年 6 月的排行榜图表 根据上面的图表，很难分析大体情况，所以提供了下面的数值排名。注意下面列出的是前 21 个编程语言： 1 JavaScript 2 Java 3 PHP 4 Python 5 C# 5 C++ 5 Ruby 8 CSS 9 C 10 Objective-C 11 Perl 11 Shell 13 R 14 Scala 15 Go 15 Haskell 17 Matlab 18 Swift 19 Clojure 19 Groovy 19 Visual Basic 跟上一季度一样，JavaScript 比第二的 Java 只是稍稍领先了一点，这些数值差距是非常微小的。这些能体现编程语言的持久热度，但是也一定程度反映了语言的多样性和在企业和初创企业中的作用。 除了这两个语言，前十的语言位置非常稳固的。除了一些小的改变，事实上这些年都差不多是这样的排名。同时发现这是一定周期支持一种特定的语言或者是一种风格的语言，简单的来说，最受欢迎的语言几乎没什么改变，对未来也没什么倾向性的变化，这是不是意味着语言的采用和语言的 分化 已经达到了顶峰？ 除了前十，值得关注的变化有： Go ：一年前，我们预言 Go 在 6 -12 个月的时间内会成为前 20 的语言。在 1 月份的排行中 Go 成为了第 17 位，预言成真。现在 Go 是第 15 位，超越了 Haskell 和 Matlab。 Erlang ：这是并发方面开发者长期选择的一种语言。Erlang 之前从第 26 位升到第 25 位，这主要是两周前 Erlang 抛弃了之前的 MPL 协议，选择了 Apache 协议。 Julia/Rust :：历史性原因，这两个语言的发展轨迹很相似。上一季度，Rust 向上跳了 8 位，Julia 向上跳了 3 位。此次排名 Julia 比之前上升了 2 位到第 52 位，Rust 向上跳了 2 位到第 48 位。继续保持观望！ CoffeeScript :：2013 年 Q3 排名 17，之后排名 18，18，21，现在是 22。重回前 20 这不是不可能的，至少找到了立足点和稳定的地位，但是前景并不乐观，因其缺乏动力和竞争。 Dart / Visual Basic ：这是经常被问到的两个语言。Visual Basic 现在跟 Clojure，Groovy 排名第 19，未来是否还会在前 20 还不是很明朗。Dart，有着 Google 血统，还有 JavaScript 方面的野心，还在稳定增长中，比 Google 的另一个语言 Go 稍稍落后那么一点点，现在是从第 34 位升到第 33 位。 Swift ：这个月的排名因为某些原因有些小小的问题。在几方的要求下，苹果 WWDC 前，我们去看 Swift 是否从第 68 升至第 22 位。不幸的是，因为 Stack Overflow 页面结构的改变，数据抓取失败，所以只能手动查看，缩小了范围，Swift 直接在前 20 位以后，排名 21。 在我们官方排名中，当然会要求完整的 Stack Overflow 数据，所以 WWDC 之后又收集了一次数据，最新的结果 Swift 从第 21 名升至第 18 名。这就是 WWDC 效应，Swift 排名历史从 68，22 到 18，成为第一个在一年内挺近前 20 的语言。 未来 Go 和 Swift 是前十的种子选手，这也许只是时间问题，我们将会继续关注！Go 也许会取代 Objective C, Perl, Shell, R 和 Scala 的位置。Perl 和 Shell 无处不在，但是频率却不够高；R 和 Scala 非常流行，但是使用范围不够广泛。 Go 成为一个非常受欢迎的现代化后端语言，Swift 也在 iOS 占有一席之地，下一次排名应该会更有趣～ via redmonk.com http://www.oschina.net/news/63983/redmonk-2015-june?p=3

5200 次阅读|1 个评论

UltraEdit语法高亮设置

dkwork 2015-4-25 18:04

UltraEdit是一个常用的文本编辑器，很多程序员喜欢用它代替编程语言原生的IDE编辑器。其中一个非常有用的功能是对编程语言中语法保留字高亮显示，提升程序可读性。UltraEdit对多种常用的编程语言可自动语法高亮显示，实际上都是通过自定义wordfile文件实现的。 UltraEdit15.0版后，wordfile文件改为目录，可以设置多个文件（后缀为.uew)。加亮文件与文件后缀名相关，可在相关文件第一行看到。 由于内置的语言高亮种类有限，可以自己写wordfile文件对新语言进行定义高亮。但是ultraedit的公司提供了很多种预定义的文件供直接下载。地址为 http://www.ultraedit.com/downloads/extras/wordfiles.html#wordfiles 本人需要使用arduino的语言（后缀为INO）可直接下载得到。但是将其放入program files的wordfile文件中始终无效。在该公司的问题库中找到答案。原来在win的user文件夹中还有一个wordfile文件夹，这个文件夹中的文件才是每次程序读入的文件。 该文件夹位置为%appdata%\IDMComp\UltraEdit\Wordfiles\，可在资源管理器中直接输入即可。也可在Advanced - Configuration - Editor Display - Syntax Highlighting中看到实际位置。 加入ino文件的wordfile文件后，重启UltraEdit，再次打开ino文件即可发现关键字已经高亮。

个人分类: 计算机|11508 次阅读|0 个评论

[转载]第六代编程语言及其软件开发环境的科学原理和底层技术

readnet 2014-8-15 17:13

邹晓辉 第六代编程语言及其软件开发环境的科学原理和底层技术 已有 999 次阅读 2012-7-17 12:12 | 个人分类: 软件工程 | 系统分类: 教学心得 | 关键词:编程语言 软件开发 第六代编程语言及其软件开发环境的科学原理和底层技术——三类双语协处理之形式化双重路径 美国加州大学（伯克利）塞尔研究中心双语信息处理课题组组长 邹晓辉 中国地质大学（北京）高等教育研究所 第六代编程语言及其软件开发环境的科学原理和底层技术.ppt 新增附图： 本文引用地址： http://blog.sciencenet.cn/blog-94143-592956.html 上一篇： 回顾图灵奖（Turing Award）获得者们的贡献，可以发现：.... 下一篇： 计算机之父图灵的“图灵测试”和心智哲学专家塞尔的“中文屋子” 更多 收藏 分享 举报 当前推荐数： 2 推荐人： 杨正瓴 邱嘉文 发表评论 评论 ( 4 个评论) 邱嘉文 2012-8-23 09:03 我们改变的不仅仅是语言，而在改变智慧，从而改变世界。 博主回复(2012-8-23 09:14) ： 对头。 邱嘉文 2012-8-23 09:00 是的，形式化语言及其与自然语言差异的存在本身就说明：现实问题有可形式化和不可形式化问题的区分。当然，这种区分也会随着人们的认识和表达水平的提高而变得越来越少，这当然是科学和语言学发展的终极目标之一。 承认这种区分的存在就是缩减这些区分的基础动力。 正是在这个动力的驱使下，才会在形式化语言和自然语言之间形成互动的循环。我们往往只注意到从自然语言大陆迈向形式化语言岛屿的桥梁，而忽视了从形式化语言岛屿走回自然语言大陆的隧道。而挖通这一隧道的价值，其实不仅仅限于对形式化表达的提升，也在于对自然语言的进一步拓展和精化。能看到这个循环，才能体会到双语乃至多语编程的深远意义。 博主回复(2012-8-23 09:13) ： 嘉文早上好。 说的非常对。 “双重路径”强调的就是：（三类）双语并行，（多方）双向互动。 邱嘉文 2012-8-22 08:57 如果是，就必然有：形式化反译自然语言子集。可针对不同语种反译，得到不同语种的反译子集，于是，可用“自然语言”实现“统一编程”。此时的“自然语言”仅限于“反译子集”，而无法是“自由的自然语言全集”。当然，反译子集也可能拓广“自由的自然语言全集”。这里出现了一个循环圈。 博主回复(2012-8-22 11:29) ： 以往的语言哲学理论所论述的“语言观”即分析“语言”、“思想”或“心智”、“世界”三者的关系——早期维特根斯坦所关注的三个理论范畴也是弗雷格的“表达式”、“意义”、“指称”以及索绪尔的“能指”与“所指”（涵盖“意义”和“指称”），以及对“语言游戏”和“家族相似性”的探讨——这是晚期维特根斯坦所关注的两个实践范畴。笔者早期对中文“意”、“意义”、“义”三个类的划分，自然地引出了对中文“物”、“物理”、“理”三个类的划分，以及对“文”、“文法”、“法”三个类的划分。其中，近期对“言”和“语”两个形式类的区分，仅限于对“文”乃至“广义文本”的内部两个基本形式类的划分。而对“物之理”、“意之义”、“文之法”和“道之本”四个基本抽象类的划分，则是更深层次的“本真信息”探讨。这种基于汉语或中文思维而形成的“世界观”及其“方法论”如何与西方分析哲学的基于印欧语例如英语或英文思维而形成的“世界观”及其“方法论”之间达成有效对话呢？笔者与塞尔之间通过多次对话，终于在今年就最基本的一个抽象范畴即“基础关系”达成了一致的看法和语言描述即“Fundamental Relation”（道之本）。这也就为笔者探索了很多年的整个“文化基因系统工程”涉及的宏观哲学框架（本真信息和广义文本即涵盖所有“物类”乃至“意类”的广义的“文类”及其八大形式体系）以及可采用间接形式化方法加以描述的微观科学体系，即“言和语的关系”及其一系列可形式化描述的具体“文类”或“形式体系”——如果说这是语言和信息两个形式类的“迭交”原理，那么，“智慧化”内容就是“意类”，而“物类”则涉及一系列很具体的“个例”和“群例”及其所具有的质能载体物性特征。 博主回复(2012-8-22 11:28) ： 以往的心智哲学理论所述的两种“智能观”即阐述“强人工智能”与“弱人工智能”的两类哲学观点，实际上分别代表或表达的是人们对“第一类脑即生物脑的虚拟心理智力”和“第二类脑即物理脑的虚拟数理智能”的基本看法。两者可视为古希腊哲学“爱智慧”传统分别在心理学和计算机科学及其相应的心智哲学上的具体表现形式。换句话说，心理学研究的人类大脑智力和计算机科学研究的人工电脑智能及其相应的心智哲学进一步试图探讨在古希腊哲学家“爱智慧”传统基础之上通过自然语言形式化途径构建具有智慧科学研究性质的融智学问，其特征在于重点研究“第三类脑即生物脑和物理脑之间合理分工、优势互补，高度协作、优化互动的虚拟协同智慧”。由此区分智力、智能、智慧三个关键性基础术语，如果采用英语来描述即心理学研究的自然人大脑智力、计算机科学以及软件工程技术研究的计算机电脑智能和古希腊哲学家崇尚并追求探索且影响至今而仍在研究的智慧——融智学称之为人机协同的双脑智慧。具体反映在计算机编程语言的进化形式上就是把第五代计算机和第五代编程语言所共同遭遇的“智能化”难题“一分为三”即“（专项功能的）强智化”、“（普及功能的）弱智化”和“（整体功能的）融智化”作为“智力、智能、智慧”的体现。这三类“智”如何通过具体的语言而准确无误地表达出来而又不会引起歧义或误解呢？以往的语言学和语言哲学都没有也不可能深入地探讨过这个问题。 博主回复(2012-8-22 11:26) ： 【此时的“自然语言”仅限于“反译子集”，而无法是“自由的自然语言全集”。】这句说得很贴切。 邱嘉文 2012-8-22 08:37 现实问题 -1-自然语言可描述问题 -2-形式化语言可描述问题 -3-可反译自然语言可描述问题。 晓辉的研究是否仅限于3？ 博主回复(2012-8-22 11:41) ： 另见： 融智学问开始步入推广普及阶段 图1 广义双语教管信息处理的协同化双重路径即融智途径 http://blog.sciencenet.cn/home.php?mod=spaceuid=94143do=blogid=603507 博主回复(2012-8-22 11:33) ： 请嘉文见三类双语和双重形式化路径的附图1、2、3（这就上载）

个人分类: 计算语言学|0 个评论

你用过多少种计算机编程语言？（140707）

热度 52 ymin 2014-7-7 08:01

你用过多少种计算机编程语言？（ 140707 ） 闵应骅 在计算机发展的初期，计算机程序是用机器代码来写的，全都是 0 ， 1 排列的指令序列，看上去根本不懂是什么意思。于是，人们试图用带有含义的语言来编写计算机程序，从而产生了计算机编程语言。 从纵向看，最早出现的高级计算机程序语言是 ALGOL 60 。 ALGOL 60 是 程序设计语言 发展史上的一个里程碑，它标志着程序设计语言成为一门独立的科学学科领域，并为后来 软件自动化 及 软件可靠性 的发展奠定了基础。 2006 年 3 月 1 日，国际计算机协会（ ACM ）宣布 Peter Naur （彼得 · 诺尔， 1928 年－） 为 2005 年 图灵奖 的获得者。他生于 丹麦 腓特烈斯贝 ，计算机科学家，他投入了 ALGOL 60 的开发工作， 1960 年主编了《算法语言 Algol 60 报告》，曾任哥本哈根大学教授，是目前唯一一位丹麦籍的图灵奖得主。 2002 年，前 图灵奖 得主 Edsger Dijstra 把 Algol 60 的发展描述为 “ 一个绝对的奇迹 ” ，标志着 “ 计算科学 ” 的诞生，因为 Algol 60 首次显示了自动计算能够并且应当成为学术关注的主题。 Algol 60 的发展是一群极具天赋的人才的工作成果，其中包括几位以后的 图灵奖 获得者。在中国， 1960 年代，中国科学院计算技术研究所的董韫美（ 1936- ， 1993 中科院院士）、仲萃豪（ 1934-2011 ， 1985 研究员）等人为中国第一台半导体计算机 109 乙机研制了 BCY 算法语言，为国民经济和国防建设解决了一批实用计算问题，在国内这是最早广泛使用的最有影响的编译系统。 BCY 是 “ 编译程序语言 ” 汉语拼音 “Bianyi Chengxu Yuyan” 的缩写。这在我国应该是计算机方面突出的成就。 从横向看，现在的计算机编程语言据说有上千种。 2014 年 7 月 IEEE Spectrum 公布了最流行的 10 种程序设计语言。他们从 10 个输入源，包括 IEEEXplore,Google, GitHub 等，用 12 个指标给所有编程语言排队，得到如下图的结果。其中， W 指 Web 应用， M 指移动应用， D 指台式和企业应用， E 指嵌入式系统应用。指标综合的结果， Java 第一，把它算 100 分，其他依次排序。我们可以看到， JAVA 由于在 Web 、移动计算和桌面系统的广泛应用，实至名归地排为第一。而 C 语言虽然算比较老，但在移动、桌面和嵌入式系统中还是很普遍，得 98.9 分，名列第二。前 30 名中，还有程序库丰富的 Fortran ，属于 D 类，得 44.8 分 和人工智能语言 LISP ，属于 D 类，得 40.6 分。其实，这个排名每年都在进行，就像全世界超级计算机排名一样。不过，因为中国的编程语言榜上无名，所以就较少引起国人的注意。编程语言的发展不单是一个工作量的问题，主要牵涉到软件方法学，譬如面向对象的方法、并行编程的方法都直接指导着编程语言的发展。

个人分类: 计算机|18345 次阅读|129 个评论

项目为什么失败了？----领先技术的诱惑

Enago 2014-6-19 16:12

科研人员或者技术人员都有一个共通的毛病，很难抵挡所谓的领先技术的诱惑。比如那些程序员，看到那些新出来的编程工具或者编程语言，禁不住总是会靠近去闻一闻，嗅一嗅，摸一摸。遇到好玩的，总也会想着，要是能在新的研究或者项目中用上，那一定是很酷的。 科研项目通常是为了实现一个或者几个主要的科研目标，只是现在的科研装置越来越复杂.............. 查看 详细全文 请点击链结造访 英论阁官方部落格 ※ http://enago.cn/blog/项目为什么失败了？-领先技术的诱惑/ ※ 博客内容皆由英论阁资深学术专家团队撰写提供 § 英论阁专业团队提供 英文论文编辑 、 SCI 论文润色 、 全套式发表支持 http://www.enago.cn §

个人分类: 科研出版趋势|3930 次阅读|0 个评论

什么是最好的编程语言？(怎样才能爱上编程呢？)

热度 1 bigdataage 2014-3-11 12:35

什么是最好的编程语言？(怎样才能爱上编程呢？) 经常有人会写点评论编程语言的文章，可能是一些很古老的快被遗忘的语言，也可能是正在流行的新语言。现在我也要写点什么，写出了我对编程语言的一些想法。 免责声明：除非你精通三十门以上的语言并且能够很好地用他们编程（或者是其中的绝大部分），否则你不能客观地评价这些语言的好坏。是的，就像其他人写的关于这方面的文章一样，我也有自己的偏好。事实上，我认为如果你精通很多门语言，你就会认为这个话题是多么的荒诞可笑。 下面这些就是在我的博客中被评为最伟大的语言： Assembly：机器语言 C：形式化语言 Javascript：网编编程语言 Scheme：与C和Javascript相比，更轻巧，嵌入性更好，是极其灵活的编程语言 范例程序来自 Rosetta Code 合适的语言 我不把这些语言称之为合适的语言（reasonable languages）是因为他们是最好的语言（best languages）。他们是现在人们普遍使用的编程语言，人们用他们来编写软件。当然了，你可以避免这些争论而是自己去做决定，如果那样的话，进入下一部分吧。 Ada 我总是对一种语言存储安全的方面很好奇。大体来说这对于真实的操作系统和普通的一般的应用系统都是很有意义的。如果你有相关专业背景的话，并且使用这种语言的话，你不需要读下面的这一部分，但这是一种一旦你知道你需要用它来做什么，你就没有什么选择余地的语言。Ada代码： function Best_Shuffle(S: String) return String is T: String(S'Range) := S; Tmp: Character; begin for I in S'Range loop for J in S'Range loop if I /= J and S(I) /= T(J) and S(J) /= T(I) then Tmp := T(I); T(I) := T(J); T(J) := Tmp; end if; end loop; end loop; return T; end Best_Shuffle; 看起来很安全，不是吗！:) Bourne (Again) Shell 我经常考虑，难道我真的需要用shell来写Linux脚本吗？真的有必要吗？如果你不用shell写script（脚本）也没有关系，因为最终你要面对面的处理这些script，并且你还要考虑怎样在Bare Metal Age和pre-stackoverflow中处理这些问题。这种语言没有什么令人吃惊的地方，也没有什么可以扩展你的思维或让你更有创造性的特性，也难以从应用的业务角度去证明它是好的。也许仅在不知道什么情况中才可以体现出来吧。然而他在系统管理中是那么重要，并且没有看起来那么糟糕。就像是Javascript，你需要比其他语言更多的实践练习。 为什么我要用Unix Shell呢？ 我是OSX/Linux/POSIX系统管理员 为了实现自动化 为了使用命令行的强大功能 一些Bourne Shell代码。享受这些布尔表达式吧！ #!/usr/bin/env sh l=1 while do m=1 while do printf * m=`expr $m + 1` done echo l=`expr $l + 1` doneC 尽管你可能不喜欢C语言，但你必须要尊重它。他可能是最伟大的语言之一。他能真正地能编写系统级代码。它是UNIX的制造者，是所有语言的鼻祖，是通用的系统级编程语言。它久经沙场，经历时间的检验，广泛传播。太多的开发，调试，性能分析工具支持着C的发展，这也使得它减少了作为语言的缺陷（我看来，这些缺陷不多）。这是一个真正实现了其目标的语言：成为通用的语言。今天，它甚至形成了最奇怪的一个体系结构，这也使得今天很难手写出比C编辑器编译出的代码更好的代码。 尽管有这么强大的工具，但这是需要被人掌握的。这种语言很是冷酷无情，你需要懂它知道你自己在用它干什么。理解机器内部对C语言很重要，C语言可以控制机器的底层。这一点很好，有积极的一面：如果没有C语言这样的底层语言，有些事情我们做不到。C语言程序员必须要彻底理解他们自己在干什么，这一点对于长时间运行的可靠的软件是极为重要的。如果有什么事物可以分开，C语言可以很好地支持并发。C语言编写的程序运行时的效率和C语言的普遍性是一个神话！ Linux内核中的C语言代码： int next_pidmap(struct pid_namespace *pid_ns, unsigned int last) { int offset; struct pidmap *map, *end; if (last = PID_MAX_LIMIT) return -1; offset = (last + 1) BITS_PER_PAGE_MASK; map = pid_ns-pidmap ; end = pid_ns-pidmap ; for (; map end; map++, offset = 0) { if (unlikely(!map-page)) continue; offset = find_next_bit((map)-page, BITS_PER_PAGE, offset); if (offset BITS_PER_PAGE) return mk_pid(pid_ns, map, offset); } return -1; }C++ 这是一个奇怪的东西。它是我接触的第一种语言，并且我真的不知道他怎样的限制住了我的生产力并限制了我的技术直到我尝试了其他的语言。c++的坏名声是被一些著名的程序员造成的，我完全同意。C++看起来仿佛是Bjarne Stoustrup把他能想到的所有的功能都加到C中。学习掌握它的负担，使你的编程效率降低80%以上。这样考虑：你的大脑容量是X，容量有限，不管你有多少的能力，你想留下尽可能多的重要的事情。明智的做法是减少用于语言本身的脑力劳动，而是使用大脑和优化的算法。如果语言复杂，无论你有多聪明，你都要用更多的脑力用于解决这语言的语法和语义上的问题，这会使你使用更少的时间用于优化你的代码。 我认为C++是典型的例子，太复杂的事物没什么意义。我同意，用C编写大的程序是困难的（但是有例外，看Linux内核）。通过这些分析，Go，Rust和D语言似乎是更好的，但事实是C++在世界范围内却被广泛地应用。 这是一个很好的C++使用模板，以下面的方式使用C++更容易理解，而不是使用template/classes来定义。 #include #include #include int main( int argc , char** argv ) { int linecount = 0; std::string line; std::ifstream infile( argv ); if( infile ) { while( getline( infile , line ) ) { std::cout linecount : line '\n'; linecount++; } } infile.close(); return 0; } 接下来是一些模板代码，一个很简单的例子，（产生出很糟糕的代码） namespace rosettacode { template class queue { public: queue(); ~queue(); void push(T const t); T pop(); bool empty(); private: void drop(); struct node; node* head; node* tail; }; template struct queue::node { T data; node* next; node(T const t): data(t), next(0) {} }; template queue::queue(): head(0) { } template inline void queue::drop() { node* n = head; head = head-next; delete n; } template queue::~queue() { while (!empty()) drop(); } template void queue::push(T const t) { node* next = head? tail-next : head; next = new node(t); tail = next; } template T queue::pop() { T tmp = head-data; drop(); return tmp; } template bool queue::empty() { return head == 0; } } C# 这种语言旨在减少代码，增加复用性，从而提高程序员的创造性。它是面对对象，具有静态类型，有大量的库函数。你能看出它是微软由控制的。但点我不会担心，它不是一个糟糕的语言。它不是很吸引人，也许微软真正想要的就是准确性吧。相比VB这是一个过于激进的改变吧。我能使用它来做的事： windows编程 游戏开发（大多数是由于微软的强迫而使用它，我认为C/C++更好） 这种语言能做大量的事情：Unity3D, Xamarin, .NET, XNA。 下面是一些代码： using System; using System.Collections.Generic; using System.IO; using System.Linq; class Program { static SortedDictionary GetFrequencies(IEnumerable items) { var dictionary = new SortedDictionary(); foreach (var item in items) { if (dictionary.ContainsKey(item)) { dictionary ++; } else { dictionary = 1; } } return dictionary; } static void Main(string = some data; NSString *string = initWithBytes:bytes length:9 encoding:NSASCIIStringEncoding]; 对于C语言衍生出来的这个漂亮的代码，利用了C语言的所谓的“block”。 #import typedef NSArray *(^SOfN)(id); SOfN s_of_n_creator(int n) { NSMutableArray *sample = initWithCapacity:n]; __block int i = 0; return ^(id item) { i++; if (i = n) { ; } else if (rand() % i n) { sample = item; } return sample; }; } int main(int argc, const char *argv init]; for (int trial = 0; trial 100000; trial++) { SOfN s_of_n = s_of_n_creator(3); NSArray *sample; for (int i = 0; i 10; i++) { sample = s_of_n(@(i)); } ; } NSLog(@%@, bin); } return 0; } Clojure 作为一个Scheme程序员我尊重Clojure:是所谓的现代Lisp,他有一些独特的特性。我想说Clojure在编程方面的长处是和Java语言相同的互操作性和并发实用程序。它与scaling是紧密相关的，但他们的特点是不同的：lisp是面向对象和面向过程的混合，Clojure有过多的括号而使其没有lisp流行。选择这两种语言中的哪一个进行编程取决每个人不同的风格，这是因为没有长期的记录说明哪一个在编程方面更成功一点，就像Java与PHP相比，虽然他们都是运行在虚拟机上的。对于任何基于虚拟机运行的语言，另一件需要考虑的事情是运行时间：这与很小的小程序是不同的。这是一些我用Clojure所要解决的问题： 网络编程。对于网络编程，这是一个很好的选择，在这个领域Clojure看起来是十分流行的。 当你想使用JVM而没有Java技术时。程序员的快乐程度和生产率都将提高。 探索性的编程，编出的代码能修改成产品代码。这一部分Lisp也做的很好，但是Clojure是基于Java的，其有许多代码时开源的。 安卓程序开发？安卓程序开发的GUI模式很大程度是基于类继承。（意味着你不仅仅确切地使用它作为一个插件库，而是迫使你使用某些结构）。这个可以实现，但是这又不像Java继承那样自然。 经典的Clojure代码： (defn divides? (= (rem n k) 0)) (defn prime? (if ( n 2) false (empty? (filter #(divides? % n) (take-while #(= (* % %) n) (range 2 n)))))) Lisp形式的队列的定义代码： (defn make-queue )) (defn enqueue (swap! q conj x)) (defn dequeue (if (seq @q) (let (swap! q subvec 1) x) (throw (IllegalStateException. Can't pop an empty queue.)))) (defn queue-empty? (empty? @q)) D 我以前很喜欢D，D恰好就像C++一样做的很好。D1很像底层的Python。很像pythonized C或者是类似的东西。真是了不起：你感觉到了其发展迅速吧，他专注于算法而不是语言，但当你需要控制底层时，它又没将这一部分去掉。D2带来了C++的一些复杂性，这是由于Andrei Alexandrescu的创新。这使得一部分人不高兴了，虽然其确实在并发性方面做得更好了。D2再也不是一个纯粹的语言了。尽管我喜欢它，但是我还是感觉其不如C++普遍（一旦其复杂起来）。并且我认为现在Go正在吞并D的市场。尽管在语言方面真的能更快一些、更酷一点，但Walter和Andrei不能与google竞争。你可能正如我一样喜欢D，但是我不是很看好它。仅仅是追随C++或者是按照GO语言更加支持本地并发开发呢。我什么时候会使用D语言呢？ 从头开发一个项目时，与C有接口或者是与C++有联系时。你需要提前想好接口是什么样子的。对于接口，我不建议使用C++的GUI，因为其要从内部处理C++的继承，这将使得其优势发挥不出来。如果需要，就简单做一个插件库吧。（创建对象，使用其功能，而不是模板或是C++的继承） 底层二进制的编程。就像一个独立的部分，做自己的事情。 如果希望能很好地支持并发。 让我们看一些D2的惯用法,纯函数,不可变的声明。 uint grayEncode(in uint n) pure nothrow { return n ^ (n 1); } uint grayDecode(uint n) pure nothrow { auto p = n; while (n = 1) p ^= n; return p; } void main() { import std.stdio; N N2 enc dec2 dec.writeln; foreach (immutable n; 0 .. 32) { immutable g = n.grayEncode; immutable d = g.grayDecode; writefln(%2d: %5b = %5b = %5b: %2d, n, n, g, d, d); assert(d == n); } } 表的最大元素： .reduce!max.writeln; 截止至今，其是比C++更具有表达性和更清洁的语言。 Erlang 这是一个有目的性的语言。Erlang的web界面是非常清晰的：构建大规模可伸缩软实时的或可用的系统。它使用在电信、银行、电子商务、计算机电话和即时消息等方面。他的实时性也支持并发，分布和容错。其在一些要求很高的应用程序中已经得到证明，例如WhatsApp。其代码很有效，含义清晰，很可读。 看一下简单的并行程序的一个小例子： -module(hw). -export( ). start() - ], wait(2), ok. say(Pid,Str) - io:fwrite(~s~n, ), Pid ! done. wait(N) - receive done - case N of 0 - 0; _N - wait(N-1) end end. Go 我没有亲自使用过它。但很显然的是，这是google做的，其将C与C++好的部分加在一起并且在并发方面比他们都好的语言。它比C++有更好的部分，它形式简单。他没有不安全的指针，拥有包特性、函数和垃圾收集机制。未来Go可能成为服务器端语言。我什么时候要试试Go呢？ 对于服务器应用程序,需要非常高的可靠性和性能。这包括web应用程序。 对于控制底层的高效率的代码（然而，我更喜欢Erlang） Go的并行程序代码 package main import ( fmt math/rand time ) func main() { words := readAllBytes(String filename){ Path file = Paths.get(filename); return Files.readAllBytes(file); } } 我才你已经写过Java程序了，因此我不会解说类定义来烦你了。 Javascript 2010年代的通用网络的语言。有趣的是,虽然此前被视为一个有缺陷的和功能有限的语言,但现在大量的程序员对其进行了良好的改造,现在已经成为一种伟大的语言。特别是如果你看了它所有的库，你会发现这些库弥补Javascript的设计的缺陷(比如一个模块系统)。最后要感谢这一点,现在我们甚至把Javascript用在服务器端,这种前后端的对称式编程给我们带来了美好的生活。 有很多研究和努力投入到了改善Javascript的性能、优化Javascript的编译器中。这实际上证明了社区是极其伟大的(如果不是最大的)语言来支持者。有趣的是,你会看到无数的库在做同样的事情,这使得库成为竞争最激烈的领域之一。看Grunt、Gulp等，真是太疯狂了。 下面的代码显示了Javascript基于的原型类和继承机制： function Car(brand, weight) { this.brand = brand; this.weight = weight || 1000; } Car.prototype.getPrice = function() { return this.price; } function Truck(brand, size) { this.constructor(brand, 2000); this.size = size; } Truck.prototype = new Car; var cars = ; for (var i=0; i console.log(cars ); console.log(brand: +cars .brand+. weight: +cars .weight+. + (( cars .hasOwnProperty('size') ) ? size: +cars .size : )); console.log(Car: %s. Truck: %s\n, cars instanceof Car, cars instanceof Truck); } 这显示了使用Lo-dash库的代码: var characters = ; var youngest = _.chain(characters) .sortBy('age') .map(function(chr) { return chr.name + ' is ' + chr.age; }) .first() .value(); 如果你是熟悉Javascript的细节的话（就像例子中一样），你会我发现将两种风格混合在一起很酷。 OCaml 它有几分像Haskell，但更能满足程序员的想法。如果需要的话，一些取舍会使问题更容易解决。面对对象的方法看起来更容易工作。有人使用他，我估计就是他在这一点上超过了Haskell。看下面的代码： let n_arrays_iter ~f = function | ] ] as $s) $result # memoized multipliers = (2, 3, 5) multindeces = # index into _h for multipliers multvalues = for x,i in zip(multipliers, multindeces)] yield h while True: h = min(multvalues) _h.append(h) for (n,(v,x,i)) in enumerate(zip(multvalues, multipliers, multindeces)): if v == h: i += 1 multindeces = i multvalues = x * _h # cap the memoization mini = min(multindeces) if mini = 1000: del _h multindeces = # yield h Ruby Ruby来自Rails。这个简单的原因就可以使它不在这个列表中。当然了，现在可以看到许多其他的程序，但都是来自于Rails。在那以前，Ruby是一种来自日本的很难理解的语言。这是一个对于鼓励快要消失的编程语言成为极其流行的语言的很好的例子。 我以前从许多Ruby程序员那里听到，当然我也是一个很熟练的Ruby的程序员，他们说这是一个令人愉快的语言。换一句话说，这是一个绝不会令人沮丧的语言，我不知道这是来自语言或者是Rail本身。很早以前就被metasploit(一篇文章)指出来了。 这是用Python写过的代码，这里用Ruby再写一遍。风格不同，体现出了Ruby更有“function”风格。 hamming = Enumerator.new do |yielder| next_ham = 1 queues = { 2 = , 5 = .each {|m| queues (next_ham * m)} next_ham = .collect {|m| queues }.min .each {|m| queues .shift if queues == next_ham} end end idx = 1 hamming.each do |ham| case idx when (1..20), 1691 p when 1_000_000 p break end idx += 1 end Scala 似乎是在JVM方面很有优势。我很确信，它突出的原因是与Clojure或其他大的流行的语言相比，它更是语法方面很简单。这种语言也在这个列表中的原因是其可与Java很好地结合在一起。看下面的Hofstadter Q序列问题代码： object HofstadterQseq extends App { val Q: Int = Int = n = { if (n = 2) 1 else Q(n-Q(n-1))+Q(n-Q(n-2)) } (1 to 10).map(i=(i,Q(i))).foreach(t=println(Q(+t._1+) = +t._2)) println(Q(+1000+) = +Q(1000)) } Scheme 这种语言在这个列表中，会有很多人对此有争议，对此有三点理由： 缺乏控制质量的方法 很少有函数库 性能不佳 第一点是确实的，对于解决问题你有许多方法，但是没有哪一个是首选的有效的方法。第二点也是真实的：有函数库，但是都是分散的。语言方面的分散使得需要寻找可供使用的代码是很显然的：你需要用你自己的方法实现。这也许不是十分困难或者是耗时的，如果你要使用带有很好的FFI支持的Scheme实现，例如Gambit或Chicken Scheme，你需要使用C语言的那些函数库。这与你可能想的相反，我是这样做的，并且能很好的工作。但最后，表现不佳。实际上这是完全错误的。像Gambit那样实现是非常快速的，并且你还能优化它。从算法优化，到全局模式编译器声明。当然了,C代码可以很容易地在必要的时候组织代码。 是的,我对于Scheme是狂热的。但是,我承认它有一个致命的弱点:对于共享代码，它太差了,只有一个不太好的社区。它是如此的灵活,以至于每一个程序员都希望自己能对于问题提出完美的解决方案。Java在这方面是完全相反的:Java社区中有杰出的个人或小团队，有试探形式的编程，未经证实的大型团队。但在这种情况下，是非常好的，你可以在一个非常快速和愉快的环境中发展。最后,语言的另一个非常有趣的特性:您可以很容易地用一个Scheme-to-Js编译器编译为Javascript,所以你可以享受在节点在服务器上编程的乐趣。以下是我使用这个语言具体的例子: 需要快速编程且不需要只在像Python或Ruby中提供的库 在C或C++平台的开发的脚本程序。 为了构建一个需要从基础代码扩展出大部分代码的应用程序 对于游戏和OpenGL/ES-based多平台的应用程序。 这是一个Scheme代码示例。虽然有函数库，但你需要自己去实现各部分功能代码，因为没有什么可用的。都要去实现： ;;! Recursive map that applies function to each node (define (map** f l) (cond ((null? l) '()) ((not (pair? l)) (f l)) (else (cons (f (map** f (car l))) (f (map** f (cdr l))))))) ;;! Explicit currying of an arbitrary function (define (curry fun arg1 . args) (if (pair? args) (let ((all-args (cons arg1 args))) (lambda x (apply fun (append all-args x)))) (lambda x (apply fun (cons arg1 x))))) ;;! Implementation of filter, with the match macro (define (filter p lst) (match lst ('() '()) (((? p) . tl) (cons (car lst) (filter/match p tl))) ((hd . tl) (filter/match p tl)))) 再看看 these other interesting examples(一篇文章)吧！ Dinosaur languages 这种语言无所谓好坏。似乎我们仅仅是将其忘记了，没有什么特别之处，也没有什么理由吸引我们去使用这种语言。也许我们是错误的。 Assembly 事实上再也没有人用Assembly（汇编）真正编程了，因为编译器已经真的很好了，似乎也不用汇编来优化了。我认为总是有人可以用汇编写出极其优秀的代码，但那样的人必须是足够聪明的。 但是也有一个必须使用汇编的地方：终极编程。用SICP和Lisps对编程有特别好的启发，但是我相信如果从语言的最基本的地方理解也能得到启发：就像处理器指令序列，抽象的语言结构,无论是在声明,逻辑、功能或面向对象方面都有启发。对程序员的大脑有好处。这是一种伟大的语言。什么时候使用呢： 为了学习 系统级编程需要使用的时候 ·当你需要手工实现某些功能时 Common Lisp 我过去使用Autolisp、AutoCAD，但需要在Lisp、Scheme、Clojure中做决定时,我选择Scheme。对于我来说，在前面提到的三种语言中，它排名第三。它感觉起来有些复杂，没有了lisp中的美丽，优雅和简单。我会用它来进行快速建模，但现在已经拥有的库，使我们可以不用它解决问题。并且我认为有拥有更好的库的语言。 Perl 显然是一个具有宗教性质的语言，这种语言拥有自己的宗教团体。有这样一个事实是语言学家Larry Wall将创造性加入到这种语言中。感觉Latin真的是很迷人呀。伙计们，一定是有某些原因才使仍有很多杰出的人在讨论这种语言。这种语言的精髓被Larry写过的话描述了出来：汇编语言可以写出一起东西。 总的来说,我对Perl语言的概念有很深刻的印象。但其有趣的语法也可以导致产生出很多的错误(Lisp中很多地方使用宏)。我认为这种语言的伟大的是在解决小问题时非常方便：它有一个很全面的库(CPAN)，提供了几乎任何你想要的方法,这使得解决问题很方便很简单。使用Perl可能出现的最坏情况是，为了改变你的系统，你要学习很多的东西。Ps:我已经被告知Perl的对对象支持是极其可怕的，但我认为这也是一个好处(我可能是偏激的),但我也怀疑这种说法。 看看这两大项目:POE(反应系统的框架、合作多任务处理和网络应用程序),和一个实时web框架Mojolicious。 BASIC, COBOL, Fortran, Pascal, Visual Basic… 如果你需要使用这些语言中的任意一个，上帝都会保佑你的。他们应用在特定的领域(像Fortran应用在在天文学上和HPC应用在社区中),或COBOL(在一些行业中的仍在使用的古老的系统)，但它们几乎都被社区的人们一致抨击。但我给你一个很好的理由使用这些语言：当你维护别人代码时按小时收费。对于自己的代码呢?不讨论这些:) Smalltalk 第一个面对对象的语言，但是对于我来说它似乎是被忘记了。 The Unreasonable languages 可能用于生产使用这种语言不太合理,但肯定会促使你让你成为更优秀的程序员(这是完全合理的)。你的选择是有价值的。我能说什么，我喜欢另类的观点。 Array, J 我有许多的语言需要学习，我听说他们是独特的并且学习他们将在除了语言和语法方面扩展你的思维。 Factor, Forth 基于堆栈的语言是非常有能力的并且是非常值得学习的。很能扩展你的思维。所以就在这张列表中了。 F# 这是微软想扮酷的想法。这是一个很好的语言，但是我们中有许多已经学会了远离微软了。我们有足够的其他公司出资的语言了。 Oz 这是一种非常规范的有约束力和可分布式编程的语言。它拥有大部分主要编程语言的特点(懒惰和渴望)，命令式和面向对象的。 Prolog/Datalog 声明式逻辑语言大体上是非常具有学术性质的。不过也有一些例外,可以看到在this Stackoverflow question中被看到，并对与Scheme也是如此。 Rust 对于系统编程语言Mozilla的竞争者。它没有像D一样的历史,也没有像google这样的大公司的支持，仅仅像Go一样。不过,我仍然希望看到Rust在未来可作为系统开发的合理的选择。 Shen 它在这个列表中，是因为对其类型相关的东西，我读到了有趣的东西，一些非常基础和有趣的东西是用Shen写的。然而，它的实现是极其具有实验意义的，并且这个语言有一个不可接接受的许可证。这个语言的创造者似乎生活在另一个年代。 TCL 我过去几个月,这时我发现程序与数据由同样的结构存储并且它绑定到一个我需要了解的库，这些是问题(BRL-CAD)。我想说的这是一种像其他很多语言一样被低估的语言。它也没有什么特别好的前途。 结论 我以我选择的语言开始了这个漫长的帖子。编程是一个很美妙的艺术，我真心喜欢它，我承认我偏向于使用自己的经验写这篇文章。由于太多的不确定性，选择一种语言来编程是一个很困难的事情。以我的观点看，有三点很重要： 这个工程的目的是为了创作出一个产品，还是属于一个拥有文化底蕴的组织而偏向于某一种语言吗？ 这项任务非常特殊而就是要求某一编程语言吗？ 你喜欢或者是想要尽力用这种语言编程吗？ 尽管有时打破这个规则，但这就是我解决这类问题的方法。 你有更好的代码片段显示这些语言的特点吗？ 英文原文 blog.fourthbit.com 转自： http://ourjs.com/detail/531bfa3bf21aca1267000001

5469 次阅读|5 个评论

[转载]4种不同操作系统18种不同编程语言对应的年薪水平

nadia1989 2014-1-23 10:50

4种不同操作系统18种不同编程语言对应的年薪水平 The Unix Geek网站日前根据Indeed职位搜索引擎统计出了美国不同程序员的收入情况，按照他们使用的编程语言、操作系统和应用程序接口进行分类。 下面是使用18种编程语言的程序员年薪情况： Erlang: $99,000 Objective-C: $82,000 Pascal: $81,000 C++: $80,000 TCL: $80,000 C#: $79,000 Java: $79,000 Python: $78,000 Perl: $77,000 Ruby: $74,000 COBOL: $73,000 JavaScript: $72,000 ColdFusion: $64,000 Delphi: $64,000 PHP: $64,000 Visual Basic: $64,000 C: $60,000 Haskell: $53,000 下面是按照4类操作系统划分： GNU/Linux: $86,000 Solaris: $80,000 Microsoft Windows: $55,000 Mac OS X: $51,000 最后是按照应用程序接口划分： Win32: $86,000 Tcl/Tk: $81,000 Qt: $76,000 GTK+: $75,000 .NET: $71,000 ($75,000 Visual Studio) Cocoa: $43,000 ($60,000 Mac Programming)

个人分类: 程序|2039 次阅读|0 个评论

21世纪的编程语言-Go语言学习资料完全总结（第二版）

热度 2 bigdataage 2013-10-7 17:52

21世纪的编程语言-Go语言学习资料完全总结（第二版） 第一版： http://blog.sciencenet.cn/home.php?mod=spaceuid=830496do=blogid=689520 只包括中文和英文资料。 草稿未完待续。

3345 次阅读|3 个评论

[转载]如何学会多种编程语言

deliangwang 2013-8-25 20:46

面向对象编程语言的基础理论要点： 学习基础理论要点，例如设计模式/范式，这样你就知道了在所有面向对象的编程语言中共同的知识，而不是只提高了一种语言水平。这是学习编程语言最有效的方法。 编程语言的类型有很多种，例如函数式语言，面向对象语言，面向数据语言（更多）。通过把各种语言归纳分类，这600种语言大概可以分成50类。通过学习每种分类的基础理论要点，再学习分类中的不同语言就变得容易多了。这里我给出一个例子。 对于面向对象编程语言，有5个基本原则能帮助你写出整洁优秀的代码。这些原则由Bob Martin总结，叫做SOLID原则。这里有一篇文章用图片形式很好的对这些原则进行了解释说明。这些原则是： 一个对象只承担一种责任，所有服务接口只通过它来执行这种任务。 程序实体，比如类和对象，向扩展行为开放，向修改行为关闭。 子类应该可以用来替代它所继承的类。 一个类对另一个类的依赖应该限制在最小化的接口上。 依赖抽象层（接口），而不是具体类。 通过学习这些原则，你可以在所有面向对象语言里更有效的进行编程。当然，你需要学会一门这种类型的语言来练习这些原则，但这是完全值得的。 各种面向对象语言间的不同之处： 同属于面向对象语言，它们之间存在大量不同之处： 语法：了解各种语言在语法句式上的差异有很多好处，其中之一能帮助优化你的编码。通过让一个方法或类跟它的行为在特征是保持相似，这能让程序更容易懂。 独特性：每种编程语言跟其它种比起来都有自己的独特之处。Java有私有方法和数据自定义上的特点，Ruby在Web应用上有很强的优势。 总之，学习各种语言之间的区别很重要。这种语言可能比那种语言中某些方面更容易使用或更强大。 总结 学习编程语言最有效的方法是学习它们的基础性的模式/范式，这比单独学习每种语言更高效。通过学习这些基础原理，你可以把它们应用到很多其它类似的语言里。学习各种语言之间的差异，这能帮助我们在面对各种情况时选择更合适的语言。

个人分类: 编程笔记|1599 次阅读|0 个评论

[转载]30种编程语言的比较选择问题

deliangwang 2013-8-25 20:28

本文涉及到的编程语言：C、C++、Java、C#、Prolog、VB、Scala、Clojure、Haskell、Ada、Python、Ruby、Pascal（Delphi）、Fortran、Lisp、matlab、Perl、Erlang、Boo、Tcl、Bash、C shell、Objective-C、PHP、PL-SQL、Transact-SQL、ASP、JSP、Lua、smalltalk、R、D 涉及到的工具：sed、awk、grep 我们现在学一门语言，大部分是要用到了才学（基本上是中国的公司用什么我们学什么），基于兴趣的不多。 比如，大头肯定是C++和java，因为这个最容易混饭吃。最近多玩用了Erlang，还有不少公司跟风上了Erlang，让这个沉默了好久的语言忽然被明星了。 大公司一般除了C++外，都会招Java，事实上，互联网公司，Java占了半壁江山（当然，没选java架构的除外，有不少.net族的）。所以，生活在贫困线上的广大中国程序猿很少有人会去看看诸如scala之类的玩意。不过作为胶水，python、perl还是有一定的用户量的。 似乎，我们生活中只有这么几种语言。。。 貌似，遇到一个问题，我们该选择什么语言呢？虽然每个语言本质上都是图灵完备的，但是能用prolog写出来的东西，如果用别的语言写，会无比痛苦。这就是不同语言存在的原因：不同的问题，不同思考方式（编程范式）。 解决问题case：已知大量事实，和事实之间的约束，要求挖掘关系。 果断用 prolog 族语言。 例如，汉诺塔、地图着色、数独问题、八皇后问题等这种考验智商，并且需要从已知规则中发现模式的问题。拥有一大堆已知案例的应用（例如大部分的人工智能情况） 应用程序 case：从小到超大型应用程序，非完全互联网应用 这也是大部分软件公司遇到的情况。一般有几种没办法分出高下的解决方案： C++，Java，C#，VB 。当然，这里面可以有CLR和JVM的不同衍生。例如，理论上，你也可以用 scala 来代替（不过估计大型公司不会冒这个险）。还是在理论上，你也可以用函数式编程的 Clojure 和 Haskell 来做（估计没人会那么傻）。还是在理论上，也可以用 Ada 这种强悍的通用语言，但估计没人愿意接收比C++还复杂的编程语言。理论上（基本只能在理论上），不嫌弃的话 smalltalk 也行。还是在理论上， python、ruby 等配合一定的图形界面库也可以胜任（但项目大到一定的程度是，你会欲哭无泪）。 但是，我另起一行。有个语言： D语言 。我个人不认为不可以列入首选名单。但是貌似知名度不行啊。。。。企业支持少啊。。。。。确实是门优秀的语言。C++太尾大不掉，需要一种语言，让C++成为纯粹的C++。 稍小一点规模的，无法接受面向对象的程序员，有不少用 C 的。虽然OOP程序员看他们像是不开化的人，但是他们有他们的哲学（我从嵌入式开发过来，相当长时间内也摆脱不了C，总本能的排斥OOP） 解决问题case：程序规模不是很大的偏数学问题 曾经很多人用 Pascal （包括扩展的 Delphi ），曾经很多人用 Fortran ，但是都明显在退步。大型通用语言（ C++、Java、C# ）表明了他们在各种环境的适应能力。 lisp 系列也在一些问题上展现出古老的魅力。（但这个语言远没有《黑客与画家》的作者给我们描述的那样神奇，个人认为。不过我的C++风格思想占了主导，可能没办法公正的评价lisp，但是据我的使用lisp经验，在大部分情况下，我最后还是放弃了它。因为大部分情况下我总能找到用C++（或其他OOP语言）更好的原因） 另外，读研的一般都用过 matlab 。这个工具，两个字：强大！不过仅指科学计算方面。脱离了这个方面，就得考虑合不合适了，毕竟固定的矩阵思维不是啥情况都有效的。我用matlab最多的是神经网络，图片和信号处理。毫不夸张的说，matlab活脱脱一个photoshop啊。。。（当然，你得会用。。。）不过matlab的神经网络确实不行，做的太差了，小规模的网络可以，3层不用BP的F网，几十个就挂掉了。有这个需求的用ANN吧。（还是C++，偷笑） 特殊应用case：需要大量处理字符串的应用 首选利器是 Perl ，不过如果你习惯了 sed、awk、grep ，也能很方便的完成相同的功能，但perl是吸收三家所长做的。 其次是 C++ ，别拍我。诸位用过 regex 吗？就是 boost 里的那个，最近被并入 C++11 啦。有了正则表达式的C++，处理字符，无敌了很多哇。当然，Java程序员别拍我，我知道这种库一个大型的通用语言都会有。我提C++，一般顺带着不否定Java和C#能以相似的代价完成相同的功能。 特殊应用case：需要一个胶水，粘结不同语言写出来的程序 首选是 python 。俩字：精简（呀，这么说一个强大的语言有点太轻浮了，但比起ruby，确实简单呐。。。）（另外 Boo 在.net是可以用来取代python） 其次是 ruby 。俩字：复杂 毕竟，没有rails，ruby根本火不起来。事实证明，python的哲学很对。当然两种语言有很多细节的不同，甚至在编程范式上不同（真想不明白白ruby支持多种范式怎么可能是个优点？市场证明了python的纯粹） 特殊应用case：自动化测试 不用问了，肯定是 tcl 了。 由于这个特殊应用，所以个人用户基本用不到，大部分是嵌入式公司。华为、数通、迈普等。。。 特殊应用case：系统底层 这个肯定是 C 了。操作系统，驱动，底层软件，大部分都是C写的，调用API，如果不用微软的Activex之类的技术，还是得老老实实用C API的。 特殊应用case：系统管理 这个系统管理，一般指linux的。首选肯定是各种 shell 啦： Bash、C shell 特殊情况case：苹果平台 我们没得选。。。。 objective-C 特殊领域：嵌入式 大部分都是C了。不过andriod平台和苹果平台就得听话了。 gmszone 网友建议把Ada也放在这里，我不否定Ada在嵌入式领域的广阔未来和实实在在的实力。但C主导了嵌入式这么久，程序员基本没办法接受别的思维了。比如ARM，三年前我用的Xscale，我实在不愿意想象放弃C。嵌入式的玩意对错有时候根本没办法说，所以很重要的是经验，前人的积累，所以就像垄断一样，不是革命性的优秀根本无法动摇根基的。我用过spartan的FPGA，我记得当时选的core也全部是用C做编程接口。所以，很抱歉这里我无法接收该网友的意见。 特殊应用：网页 嵌入网页内的，最火的肯定是 PHP （后端）和 javascript （前端）了。前者代替了古老的cgi。 但是， java 系的 jsp 内嵌 java ， asp 内嵌 C# ，都是php的强劲对手。 通用语言在各个方面咄咄逼人。 特殊应用：数据库 就是比哪个 SQL 版本更被人接收。标准sql自然不必说，根据排名， PL(SQL)/Transact-SQL 上榜。 特殊应用：并行，分布式 并行越来越重要了。 首选 Erlang 。 但是，基于已有的条件，还是考虑选用通用语言的并行优化。 C++、Java、C# 等都在这方面做了很多优秀的工作。 特殊应用：特定语言的功能增强 不用问了，我想说的是 Lua 。用C++写实现，用Lua写逻辑是好多游戏的经典开发策略。（当然像Unity用的javascript，Unreal用的自己的。） 在通用大型语言的基础上学会用Lua加速，是一种很有趣的实践。 特殊应用：人工智能 人工智能上， prolog 和 lisp 是宠儿。 R 语言有时也被用于数据挖掘（但是太慢了

个人分类: 编程笔记|3224 次阅读|0 个评论

代码江湖--2013年8月TIOBE和GitHub编程语言排行榜分析

热度 2 bigdataage 2013-8-6 16:20

代码江湖--2013年8月TIOBE和GitHub编程语言排行榜分析 TIOBE排行榜： http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html Top Languages on GitHub： https://github.com/languages 编程，我虽然会，但很外行， 不过也要就自己了解的语言表达一下自己的观点。 由于TIOBE 本月新增了 16 个额外搜索引擎， 排行榜变化较大。 1. C语言从第1成为了第2, 据说可能和国内学校放暑假有关系（搞笑的， http://blog.jobbole.com/44972/ ），说实话，C语言在Top 10 就够了，C的优点很多，可以操作底层，但是写起来真的很麻烦， 如果把大量perl，python和Java代码改写为C, 估计手指都会敲断。 在GitHub中排第7， 这是合理的，会是常态。 2. Python, 我都不想说什么了，慢的要命，它应该会被Perl 6和Go取代, 真不知道为什么那么多人用，python 3 与 2 不兼容， PyPy也不支持python 3，很多库python 3都不能用. 我用python 3写过几十个程序（5000行以内），无论是写代码的效率还是运行效率，perl甩它N条街。python的语法的确很唯一，写出来的代码很工整，很容易读，但是Perl和Go也可以啊， 自己不要乱写就行了。python还玩儿科学计算，我在草稿纸上算都比它快，这方面Julia、R、Matlab、C++都可以秒杀它。 3. Perl 语言 , "Programming Perl: Unmatched power for text processing and scripting.", 这句话不是吹的，名符其实。 我写过的perl代码应该在5万行以上，体会也可以 总结为这句话 “Unmatched power for text processing and scripting”。 Perl 6可能会在2014年的圣诞节推出正式版，更强悍。在TIOBE的排名下降到了11，在GitHub排第9, 都有上升的空间，有希望杀到第5. Perl的正则表达式引擎比Python快很多，测试过，很明显， 比Go语言的也快。 4. MATLAB， 不是开源的，包的确不少，但语法和运行效率也不行。Julia语言正式版一旦推出，必将秒杀它。要不是因为数值计算，我绝对不会去用Matlab，由于时间关系，没有去学C++数值计算， 主要是解微分方程组，画动力系统在相空间中的轨迹，用MATLAB都不用学，很简单； 用C/C++可能会很麻烦（？）。 GitHub（28名）， TIOBE（15名），应该会下降，跌倒50名以外。 5. R语言， GitHub（27名）， TIOBE（32名）， 有上升空间，能进入前20。 但Julia语言正式版推出以后，会下降，跌出前30。在生物学，特别是bioinformatics中用的很多，在经济学中好像 也是。统计和画图都很牛，不错。 6. D语言，不是要取代C吗？ 可能么？ GitHub（30名）， TIOBE（22名）。可能会像拉美国家一样，只能停留在中等发达国家水平，由人决定的。 D语言进不了Top 20. 7. Fortran 语言 , 老人家还再用，GitHub（43名）， TIOBE（31名）， 会迭出前50的，和Matlab一样。 8. Clojure 语言 , GitHub（25名）， TIOBE（500-100名），我好伤心，怎么没有把Lisp的份额抢过来，闯进前20。 9. Opa 语言 , http://opalang.org/, GitHub（94名）， TIOBE排名居然没有考虑它（ http://www.tiobe.com/index.php/content/paperinfo/tpci/tpci_definition.htm ）， GitHub（94名）， 不是可以一统江湖的Web开发语言么？ 不是十种可能改变IT行业走向的编程语言、云计算最具潜力语言、云计算时代最具潜力的12种编程语言之一么？ （ http://developer.51cto.com/art/201201/311187.htm http://tech.ccidnet.com/art/33947/20120817/4176465_1.html ）。 “Opa replaces Javascript, HTML, CSS, PHP, and SQL with one unified language. ”， “Opa unified all web programming Javascript, HTML, CSS, PHP, and SQL.” 不是比Node.js还牛么？ （ http://www.csdn.net/article/2012-03-05/312756 ） 怎么排在了100左右？ 难道就像Science Signaling 一样，视排名（影响因子）如粪土？ 可编程语言的存在就是为了让人使用啊！！！ 何时能进前10,超过Javascript和PHP？ 可能吗？ 10. Go语言, GitHub（24名）， TIOBE（26名）, 从刚一发布就以光速上升， 不过在意料之中，为这个时代而生。 下个月进入Top 20, 2013年以内进入Top 10， 2014年以内进入Top 3， 2015年以内成为第一。 有5个原因： (1) 开发效率： 可以和脚本语言相比，哪怕是text processing也方便。语言本身的特性就兼顾了很多方面, 这是最重要的。 (2) 编译和运行效率： 不错，只比C语言慢点。 (3) 核心开发团队的阵容很强大。 (4) 背后有Google鼎力支持。 (5) 开源。 11. Julia 语言 , http://julialang.org/ , 还没有发布version 1.0, 故TIOBE排名没有考虑它，GitHub（Top 100）。 Julia语言寻求成为数值计算中的C语言( http://www.csdn.net/article/2012-02-23/312315 ), 可能取代Matlab和R。 个人很看好， 也是5个原因，同上，把 Google改为MIT就可以了。 想写的其实很多，但不会五笔打字，Linux上的拼音输入法也没有模糊拼音设置（c ch, s sh, in ing, en eng,......., 我完全分不开啊！），打字太慢，不写了。 有谁知道哪一种 Linux上的拼音输入法能 设置 模糊拼音么？

6721 次阅读|5 个评论

邹晓辉特邀报告要点片段：双重形式化途径与七代编程语言发展阶梯

geneculture 2013-6-5 14:59

个人分类: 双语信息处理|1494 次阅读|0 个评论

第七代编程语言真正兼顾人机双方各自的特点（特邀报告）

geneculture 2013-6-5 10:12

给《计算机应用和软件》的特邀报告： 第一代编程语言完全照顾机器硬件； 第二代编程语言试图兼顾人机双方； 第三代编程语言转向人机交互过程； 第四代编程语言突出交互界面对象； 第五代编程语言试图利用专家知识； 第六代编程语言试图照顾大众用户； 第七代编程语言真正兼顾人机双方。 结论：既然只顾一方行不通，那么， 就务必回到兼顾双方的立场上来！。 这也是主体间性的一种价值体现嘛！ 直接采用无需再做特别界定的三类双语涉及的六种语言，即： 十进制和二进制两种算数语言、中文和英文、领域术语和普通俗语。 这是以往任何一种编程语言所没有具备的特征和优点，因为， 它既兼顾了人机两方面，又避免了在人机两方面左右为难的格局， 即：无法兼顾人机两方面各自特点的困境。

个人分类: 双语信息处理|0 个评论

[转载]30种编程语言的比较选择问题

runningabc 2013-4-18 15:24

本文涉及到的编程语言：C、C++、Java、C#、Prolog、VB、Scala、Clojure、Haskell、Ada、Python、Ruby、Pascal（Delphi）、Fortran、Lisp、matlab、Perl、Erlang、Boo、Tcl、Bash、C shell、Objective-C、PHP、PL-SQL、Transact-SQL、ASP、JSP、Lua、smalltalk、R、D 涉及到的工具：sed、awk、grep 我们现在学一门语言，大部分是要用到了才学（基本上是中国的公司用什么我们学什么），基于兴趣的不多。 比如，大头肯定是C++和java，因为这个最容易混饭吃。最近多玩用了Erlang，还有不少公司跟风上了Erlang，让这个沉默了好久的语言忽然被明星了。 大公司一般除了C++外，都会招Java，事实上，互联网公司，Java占了半壁江山（当然，没选java架构的除外，有不少.net族的）。所以，生活在贫困线上的广大中国程序猿很少有人会去看看诸如scala之类的玩意。不过作为胶水，python、perl还是有一定的用户量的。 似乎，我们生活中只有这么几种语言。。。 貌似，遇到一个问题，我们该选择什么语言呢？虽然每个语言本质上都是图灵完备的，但是能用prolog写出来的东西，如果用别的语言写，会无比痛苦。这就是不同语言存在的原因：不同的问题，不同思考方式（编程范式）。 解决问题case：已知大量事实，和事实之间的约束，要求挖掘关系。 果断用 prolog 族语言。 例如，汉诺塔、地图着色、数独问题、八皇后问题等这种考验智商，并且需要从已知规则中发现模式的问题。拥有一大堆已知案例的应用（例如大部分的人工智能情况） 应用程序 case：从小到超大型应用程序，非完全互联网应用 这也是大部分软件公司遇到的情况。一般有几种没办法分出高下的解决方案： C++，Java，C#，VB 。当然，这里面可以有CLR和JVM的不同衍生。例如，理论上，你也可以用 scala 来代替（不过估计大型公司不会冒这个险）。还是在理论上，你也可以用函数式编程的 Clojure 和 Haskell 来做（估计没人会那么傻）。还是在理论上，也可以用 Ada 这种强悍的通用语言，但估计没人愿意接收比C++还复杂的编程语言。理论上（基本只能在理论上），不嫌弃的话 smalltalk 也行。还是在理论上， python、ruby 等配合一定的图形界面库也可以胜任（但项目大到一定的程度是，你会欲哭无泪）。 但是，我另起一行。有个语言： D语言 。我个人不认为不可以列入首选名单。但是貌似知名度不行啊。。。。企业支持少啊。。。。。确实是门优秀的语言。C++太尾大不掉，需要一种语言，让C++成为纯粹的C++。 稍小一点规模的，无法接受面向对象的程序员，有不少用 C 的。虽然OOP程序员看他们像是不开化的人，但是他们有他们的哲学（我从嵌入式开发过来，相当长时间内也摆脱不了C，总本能的排斥OOP） 解决问题case：程序规模不是很大的偏数学问题 曾经很多人用 Pascal （包括扩展的 Delphi ），曾经很多人用 Fortran ，但是都明显在退步。大型通用语言（ C++、Java、C# ）表明了他们在各种环境的适应能力。 lisp 系列也在一些问题上展现出古老的魅力。（但这个语言远没有《黑客与画家》的作者给我们描述的那样神奇，个人认为。不过我的C++风格思想占了主导，可能没办法公正的评价lisp，但是据我的使用lisp经验，在大部分情况下，我最后还是放弃了它。因为大部分情况下我总能找到用C++（或其他OOP语言）更好的原因） 另外，读研的一般都用过 matlab 。这个工具，两个字：强大！不过仅指科学计算方面。脱离了这个方面，就得考虑合不合适了，毕竟固定的矩阵思维不是啥情况都有效的。我用matlab最多的是神经网络，图片和信号处理。毫不夸张的说，matlab活脱脱一个photoshop啊。。。（当然，你得会用。。。）不过matlab的神经网络确实不行，做的太差了，小规模的网络可以，3层不用BP的F网，几十个就挂掉了。有这个需求的用ANN吧。（还是C++，偷笑） 特殊应用case：需要大量处理字符串的应用 首选利器是 Perl ，不过如果你习惯了 sed、awk、grep ，也能很方便的完成相同的功能，但perl是吸收三家所长做的。 其次是 C++ ，别拍我。诸位用过 regex 吗？就是 boost 里的那个，最近被并入 C++11 啦。有了正则表达式的C++，处理字符，无敌了很多哇。当然，Java程序员别拍我，我知道这种库一个大型的通用语言都会有。我提C++，一般顺带着不否定Java和C#能以相似的代价完成相同的功能。 特殊应用case：需要一个胶水，粘结不同语言写出来的程序 首选是 python 。俩字：精简（呀，这么说一个强大的语言有点太轻浮了，但比起ruby，确实简单呐。。。）（另外 Boo 在.net是可以用来取代python） 其次是 ruby 。俩字：复杂 毕竟，没有rails，ruby根本火不起来。事实证明，python的哲学很对。当然两种语言有很多细节的不同，甚至在编程范式上不同（真想不明白白ruby支持多种范式怎么可能是个优点？市场证明了python的纯粹） 特殊应用case：自动化测试 不用问了，肯定是 tcl 了。 由于这个特殊应用，所以个人用户基本用不到，大部分是嵌入式公司。华为、数通、迈普等。。。 特殊应用case：系统底层 这个肯定是 C 了。操作系统，驱动，底层软件，大部分都是C写的，调用API，如果不用微软的Activex之类的技术，还是得老老实实用C API的。 特殊应用case：系统管理 这个系统管理，一般指linux的。首选肯定是各种 shell 啦： Bash、C shell 特殊情况case：苹果平台 我们没得选。。。。 objective-C 特殊领域：嵌入式 大部分都是C了。不过andriod平台和苹果平台就得听话了。 gmszone 网友建议把Ada也放在这里，我不否定Ada在嵌入式领域的广阔未来和实实在在的实力。但C主导了嵌入式这么久，程序员基本没办法接受别的思维了。比如ARM，三年前我用的Xscale，我实在不愿意想象放弃C。嵌入式的玩意对错有时候根本没办法说，所以很重要的是经验，前人的积累，所以就像垄断一样，不是革命性的优秀根本无法动摇根基的。我用过spartan的FPGA，我记得当时选的core也全部是用C做编程接口。所以，很抱歉这里我无法接收该网友的意见。 特殊应用：网页 嵌入网页内的，最火的肯定是 PHP （后端）和 javascript （前端）了。前者代替了古老的cgi。 但是， java 系的 jsp 内嵌 java ， asp 内嵌 C# ，都是php的强劲对手。 通用语言在各个方面咄咄逼人。 特殊应用：数据库 就是比哪个 SQL 版本更被人接收。标准sql自然不必说，根据排名， PL(SQL)/Transact-SQL 上榜。 特殊应用：并行，分布式 并行越来越重要了。 首选 Erlang 。 但是，基于已有的条件，还是考虑选用通用语言的并行优化。 C++、Java、C# 等都在这方面做了很多优秀的工作。 特殊应用：特定语言的功能增强 不用问了，我想说的是 Lua 。用C++写实现，用Lua写逻辑是好多游戏的经典开发策略。（当然像Unity用的javascript，Unreal用的自己的。） 在通用大型语言的基础上学会用Lua加速，是一种很有趣的实践。 特殊应用：人工智能 人工智能上， prolog 和 lisp 是宠儿。 R 语言有时也被用于数据挖掘（但是太慢了） 本文转自 http://blog.csdn.net/ljy1988123/article/details/7782700

5562 次阅读|0 个评论

Python编程语言书籍

热度 3 deliangwang 2013-3-14 23:22

与孩子一起学编程 其实学起来很简单，小学生也可以编程 Python学习手册（第4版） 入门从此书开始 Python入门经典 解决计算问题为主 可爱的Python 中文Python社区的心得 Python编程实践 实践从这里开始 Python标准库 懂了标准库，万事不再难 Python科学计算 终于了解了计算的力量 真实世界的Python仪器监控 数据采集与系统自动化，也可以信手拈来

个人分类: 编程笔记|6395 次阅读|6 个评论

编程语言的交互调用

deliangwang 2013-1-23 15:15

2104 次阅读|0 个评论

第六代编程语言及其软件开发环境的科学原理和底层技术

热度 1 geneculture 2012-7-17 12:12

第六代编程语言及其软件开发环境的科学原理和底层技术——三类双语协处理之形式化双重路径 美国加州大学（伯克利）塞尔研究中心双语信息处理课题组组长 邹晓辉 中国地质大学（北京）高等教育研究所 第六代编程语言及其软件开发环境的科学原理和底层技术.ppt 新增附图：

个人分类: 软件工程|2189 次阅读|4 个评论

标读“编程语言F”

geneculture 2012-6-26 23:45

FORTRAN，亦译为 福传 ，是英文“FORmula TRANslator”的缩写，译为“ 公式翻译器 ”，它是 世界上最早出现的 计算机高级 程序设计语言 ， 广泛应用于 科学和工程 计算 领域 。 FORTRAN语言 以其 特有的功能 在数值、科学和工程 计算领域 发挥着重要作用 。 目录 FORTRAN开发历史 Fortran语法的版本 FORTRAN I FORTRAN III FORTRAN IV FORTRAN 77 FORTRAN 90 FORTRAN 95 FORTRAN 2003 FORTRAN 2008 Fortran的特性 Fortran语言的Hello World程序 Fortran编译器 Fortran程序包 Fortran的将来 FORTRAN开发历史 Fortran语法的版本 FORTRAN I FORTRAN III FORTRAN IV FORTRAN 77 FORTRAN 90 FORTRAN 95 FORTRAN 2003 FORTRAN 2008 Fortran的特性 Fortran语言的Hello World程序 Fortran编译器 Fortran程序包 Fortran的将来 展开 FORTRAN开发历史 　　早在1951年， 美国 IBM公司 约翰·贝克斯 (John Backus)针对 汇编语言 的缺点 着手研究开发 FORTRAN语言 ，并于1954年在 纽约 正式对外发布。称约翰·贝克斯提出的FORTRAN语言为FORTRANⅠ，FORTRANⅠ虽然 功能简单，但它的开创性工作，在社会上引起了极大的反响 。到1957年第一个FORTRAN 编译器 在IBM704 计算机 上实现，并首次成功运行了FORTRAN程序。 　　 在1958年，对FORTRANⅠ进行了 扩充和完善 ，引进了 子函数 等概念，推出了商业化的FORTRANⅡ版本。之后，FORTRAN语言 发展迅速 ，多种版本相继在其它计算机上实现。 　　在1962年，推出了FORTRAN Ⅳ。FORTRAN Ⅳ 没有充分考虑 兼容性 ，导致FORTRANⅡ程序不能在FORTRAN Ⅳ系统中运行， 使其应用受到了很大限制，这时语言不兼容性问题和影响被突出表现出来 。此前，也出现过FORTRAN Ⅲ，但由于存在严重缺陷，没有在计算机上实现。 　　随着FORTRAN语言版本的不断更新和变化， 语言不兼容性问题日益突出，语言标准化工作被提上了日程 。1962年5月，美国标准化协会(简称ANSI)成立相关机构着手进行FORTRAN语言标准化的研究工作，并于1966年正式公布了两个标准文本：美国国家标准FORTRAN(ANSI X3.9-1966)和美国国家标准基本FORTRAN(ANSI X3.10-1966)，前者相当于FORTRAN Ⅳ，后者相当于FORTRANⅡ。基本FORTRAN是美国国家标准FORTRAN的一个子集，从而实现了语言的向下兼容，初步解决了语言的兼容性问题。通常称美国国家标准FORTRAN为FORTRAN 66。FORTRAN 66的推出在国际上产生了广泛影响，1972年 国际标准化组织 (简称ISO) 在FORTRAN 66基础上制定了FORTRAN语言三级国际标准：基本级、中间级和完全级 。 　　20世纪60代末， 结构化程序设计方法 提出后， 具有 结构化 特征的程序设计语言 开始出现，如：ALGOL、PASCAL、MODULA、C等。如何将结构化特征引入FORTRAN 66引起计算机厂商和研究机构的高度重视，许多计算机厂商开始对FORTRAN 66进行不同程度的扩充，引入了结构化特征。针对这种情况，ANSI于1976年对FORTRAN 66(ANSI X3.9-1966)进行了修订，吸收了计算机厂商所扩充的一些行之有效的功能，同时增加了许多新内容。ANSI于1978年4月正式公布了新的美国国家标准(程序设计语言FORTRAN ANSI X3.9-1978)，同时宣布撤消ANSI FORTRAN 3.9-1966，通常称新标准为FORTRAN 77(该版本原计划1977年公布)。FORTRAN 77向下兼容FORTRAN 66。在1980年，FORTRAN 77被ISO正式确定为国际标准ISO 1539-1980，该标准分全集和子集。FORTRAN 77推出后，由于具有结构化特征，在社会上得到了广泛应用，同时由于扩充了字符处理功能，在非数值处理领域也能大显身手。 　　20世纪80年代末，FORTRAN 77结构化和现代化的研究开始兴起，到1991年5月，ANSI公布了新的美国国家标准FORTRAN(ANSI 3.198-1991)。之后，ISO采纳该标准，并确定为国际标准ISO/IEC 1539-1： 1991，新国际标准 还采纳了我国计算机和信息处理标准化技术委员会程序设计分会 提出的多字节 字符集 数据类型及相应的内部函数 ， 为非英语国家使用计算机提供了极大的方便。 通常称新标准为FORTRAN 90，FORTRAN 90向下兼容FORTRAN 77。之后不久又出现了FORTRAN 95。 　　FORTRAN 90的推出，使传统FORTRAN语言具有了现代气息。Fortran 2003 的规则已经由ISO组织制定发布。 　　Windows平台下， 微软 公司将FORTRAN 90无缝集成在Developer Studio 集成开发环境 之中，推出了Microsoft FORTRAN PowerStation 4.0，使FORTRAN 90真正 实现了 可视化 编程，彻底告别了传统DOS环境(字符界面)，转到了现代Windows环境( 视窗界面 )，共享微软公司Windows平台的丰富资源。 　　在1997年3月，微软公司和数据设备公司(Digital Equipment Corp，简称DEC)强强联合，合作研究、开发和推出了功能更强的FORTRAN语言新版本：　 　　Digital Visual FORTRAN 5.0，它是Microsoft FORTRAN PowerStation 4.0的升级换代产品。DEC公司 在高性能科学和工程计算方面拥有世界领先技术，其高质量的FORTRAN编译器遍及全球 。1998年1月，DEC与Compag公司合并，DEC成为Compag公司的全资子公司，于是Digital Visual FORTRAN更名为Compaq Visual FORTRAN，其最新版本为Compag Visual FORTRAN 6.6。Compaq和HP合并之后，Compaq的Fortran小组和Intel的Fortran开发小组合并，开发出来Intel Fotran编译器9，有linux和windows2个版本，其windows版本为Intel Visual Fortran， 可以和微软的Visual Studio,net集成。Windows平台下还有PGI，Absoft，Intel等多个商业公司的Fortran编译器，还有大量小公司的免费Fortran编译器。 　 　openMPI使Fortran等语言可以容易且免费的实现 并行计算 。 　　Linux平台下，其gcc编译器默认支持fortran，另外有Intel，Sun Studio，openMPI，Photran等共享编译器和PGI，Absoft，lachy， IBM，SGI，HP等多个版本的商业编译器。 　　支持Fortran 2003标准的编译器行将推出，新版本的Sun Studio 编译器已经支持部分 Fortran 2003 语法。 Fortran语法的版本 FORTRAN I 　　最早的FORTRAN版本应用于IBM 704系统上，包含了32种 语句 ，包括： 　　DIMENSION和EQUIVALENCE语句 赋值语句 三态 算术 IF语句。以 IF 这个 陈述式检查例外情况 （ACCUMULATOR OVERFLOW, QUOTIENT OVERFLOW和DIVIDE CHECK）；IF语句以处理判断开关和判断指示灯GOTO，计算的GOTO，ASSIGN，和赋值GOTODO循环格式化的输入与输出（Formatted I/O）: FORMAT, READ, READ INPUT TAPE, WRITE, WRITE OUTPUT TAPE, PRINT和PUNCH非格式化的输入与输出（Unformatted I/O）: READ TAPE, READ DRUM, WRITE TAPE和WRITE DRUM其他的输入与输出：END FILE, REWIND，和BACKSPACEPAUSE, STOP，和CONTINUEFREQUENCY语句（为编译器提供优化帮助） 　　 FORTRAN II　 1958年IBM又推出 FORTRAN II . 支援使用者撰写副编程（subroutines）以及函数（functions）。有六个新陈述如下： 　　SUBROUTINE, FUNCTION，和ENDCALL和RETURNCOMMON接下来的几年内，FORTRAN II 继续又支援 DOUBLE PRECISION 和 COMPLEX 等资料型态（data types）。 FORTRAN III 　　IBM 继续开发 FORTRAN III 至1958年时已可以内建 组合语言码 并新增其它功能；然而这个版本却从未推出。有如704 FORTRAN 和 FORTRAN II、FORTRAN III等的开发过程包含了过多的机器相依性（machine-dependent），造成编程码不易移植到其他机器上的问题。早期提供FORTRAN版本的厂商经常为此所苦 FORTRAN IV 　　自1961年开始，由于客户的强烈要求，IBM 开始发展 FORTRAN IV ， 目的在于 移除一些FORTRAN II 中过于依赖机器本身的编程码（例如：READ INPUT TAPE）同时新增一些新的功能，如 LOGICAL 资料型别。 布尔 类型（TRUE或者FALSE）与 逻辑IF语句 则取代了 算术IF语句 。FORTRAN IV 于1962年推出，最早应用于IBM 7030（"Stretch"）计算机之上，以及其接续的IBM 7090和IBM 7094版本。 　　 FORTRAN 66　 　　 早期的FORTRAN语言发展史上最重要的一件大事也许是 美国标准协会 （ American Standards Association ，即今日的 ANSI）的委员们开始为FORTRAN制定标准规格，名为"American Standard Fortran." 1966年委员会推出两套FORTRAN标准版本 ，分别定义成 FORTRAN （基于FORTRAN IV，用来应付 de facto 标准）和 Basic FORTRAN （基于FORTRAN II，并且移除其平台依赖性）。FORTRAN 第一套标准后来被称为 FORTRAN 66 （大家仍习惯称之为 FORTRAN IV）。FORTRAN 66 有效的成功第一套工业标准版的FORTRAN。其功能如下： 　　主程序，SUBROUTINE，FUNCTION和BLOCK DATA 程序单元 INTEGER, REAL, DOUBLE PRECISION, COMPLEX和LOGICAL数据类型COMMON, DIMENSION和EQUIVALENCE语句DATA语句用以指定初始值内部和EXTERNAL（ 例如 库）函数赋值语句GOTO，赋值GOTO和计算GOTO语句逻辑IF和算术（三态）IF语句DO循环READ, WRITE, BACKSPACE, REWIND和ENDFILE语句以处理顺序读写FORMAT语句CALL, RETURN, PAUSE和STOP语句DATA和FORMAT语句中的霍尔瑞斯常数，作为子程序的实际参数最长六个字母的标识符注释行 FORTRAN 77 　　在FORTRAN 66 标准推出之后，各家编译器厂商不断推出更具扩充性的标准FOTRAN（"StandardFortran"），这使得ANSI于1969年开始着手于1966标准版本的修正工作。最后定稿于1977年，1978年四月正式推出FORTRAN。新的标准规格也就是著名的 FORTRAN 77 ，这个版本是基于FORTRAN 66之上新增许多功能，弥补过去的缺点： 　　CHARACTER数据类型，极大地扩展了的字符输入和输出以及对基于字符的数据进行处理的工具IMPLICIT语句IF语句块，以及可选的ELSE和ELSE IF从句，提供 改进了的对结构化编程的语言支持 。OPEN，CLOSE和INQUIRE语句以改进I/O能力直接访问文件I/OPARAMETER语句以指定常数SAVE语句以保存本地变量内部函数的通用名称1978年推出了一个重要的版本 FORTRAN 77 是为MIL-STD-1753Release版。这个规格由 美国国防部 制定，这个标准化的FORTRAN 77 编译器并未引入ANSI FORTRAN 77标准。一些新功能最终合并到Fortran 90 标准版。 　　DO WHILE和END DO语句INCLUDE语句IMPLICIT NONE变量，用于IMPLICIT语句位处理内部函数，基于类似的包含在工业实时Fortran（ANSI/ISA S61.1 (1976)）中的函数1991年推出IEEE 1003.9 POSIX标准版，为Fortran-77 的编程人员提供了 POSIX system上的呼叫。有超过一百种功能呼叫被定义在文件上。允许存取POSIX-相容的行程控制（process control）、信号取得（signalhandling）、档案系统控制（file system control）、装置控制（devicecontrol）、程序指定（procedure pointing），以及资料流的输入与输出（stream I/O）。 　　由于成功的修正了 FORTRAN 77 发展流程，使得原本过于缓慢重复的编程设计可以顺利的应付计算机领域迅速的变化。同时，作为将近15年的“标准FORTRAN”，FORTRAN 77成为历史上最重要的一套 电脑语言 。 FORTRAN 90 　　FORTRAN 77的被严重推迟的后续版本，非正式的名称是 Fortran 90 ，最终于1992年作为 ANSI标准 被发表。这一大版本添加了许多新特性以反映自1978年标准以来发展的在编程方面显著的变化： 　　自由格式 源代码 输入， 以及小写的Fortran关键字模块，将有关联的过程和数据组合在一起，使它们可以被其它程序单元调用，包括允许限制一些模块的特定部分访问 。RECURSIVE过程极大地改善了参数传递机制，允许在编译时检查接口通用过程的用户自定义接口操作符重载派生/ 抽象数据类型 新的数据类型定义语法，以指定数据类型和变量的其它属性可以在 表达式 和赋值语句中按整体操作 数组 （或数组节）， 由此极大地简化了数学和工程计算 。这些特性包括整体、部分和通配的数组赋值（比如用WHERE语句作选择性赋值），数组常数和表达式，用户定义的数组函数和数组构造。动态内存分配通过ALLOCATABLE属性和ALLOCATE和DEALLOCATE语句POINTER属性，指针赋值和NULLIFY语句以便于创建和操作动态 数据结构 CASE结构以用于多路选择EXIT和CYCLE语句以用于在按顺序地"跳出"正常的DO循环重复最长31个字符的标识符行内注释用户可控制的可定义的数字精度新的和增强的内部过程 FORTRAN 95 　　F ortran 95 仅是一个小改版，大部份修正了Fortran 90 standard一些较为显著的问题。虽然如此，Fortran 95 仍有不少的扩充，尤其是在 High Performance Fortran 的规格： 　　FOR ALL和嵌套的WHERE结构以帮助向量化用户定义的PURE和ELEMENTAL过程Fortran 95的一个重要补充是ISO技术报告 TR-15581：增强的数据类型工具 ，非正式名称是 可分配的TR 。这一标准定义了ALLOCATABLE数组的增强的应用，先于与完全的Fortran 2003兼容的Fortran编译器，以供使用。这些使用包括在过程伪参数列表中以及将函数返回值使用ALLOCATABLE数组作为派生的类型组件。（ALLOCATABLE数组比基于POINTER的数组更受欢迎，因为ALLOCATABLE数组是由Fortran 95保证的，当它们退出范围时会被自动释放掉，避免了内存溢出的可能性。另外，别名也不再是优化数组引用时的一个问题，可以使编译器生成比用指针时更快的代码。） 　　Fortran 95的第二个补充是ISO技术报告 TR-15580：浮点异常处理 ，非正式名称是 IEEE TR 。这一标准定义了对IEEE浮点算术和浮点异常处理的支持。 FORTRAN 2003 　　最新的版本， Fortran 2003 ，有着更大幅度的改版。ISO Fortran Working Group (WG5)的官方网站有关于Fortran 2003新特性的详细总结，并有PDF文件PDF或者压缩PostScript文件可供直接下载。 　　据该文所述，本版本的主要改进包括： 　　增强了衍生类型：带参数的衍生类型，改善了控制的可操作性，改善了结构化的创建和释放。支持 面向对象编程 ：扩展类型和继承， 多态 ，动态类型分配，以及类型绑定过程。改善了数据操作：可分配的组件（编入IEEE TR 15581），延期的类型参数，VOLATILE属性，在数组构造和分配语句中显式定义类型，增强的指针，扩展的初始化表达式，增强的内部过程。增强的输入/输出：异步传输，流访问，用户指定衍生类型的传输操作，用户在格式转换时指定舍入控制，为连接前单元指定常数，FLUSH语句，关键字的规范，访问错误信息。过程指针。支持IEEE浮点算法和浮点异常处理（编入IEEE TR 15580）。 与C语言的交互性支持国际化：访问ISO 106464字节字符和在格式化的数字输入/输出中选择数字或者逗号 。与宿主 操作系统 增强的集成：访问命令行参数，环境变量和 处理器 错误信息。 FORTRAN 2008 　　Fortran 2003之后的下一个版本是Fortran 2008. 一如 Fortran 95, 这只是一个小改版，略微更正了 Fortran 2003 的一些问题, 并且合并了 TR-19767的语言功能。 　　如同 February 2007, 新的功能包括了Co-array Fortran – 平行处理模式 BIT 资料型态。2007年8月，资料型态 BIT 被删除了。2008年2月，Coarrays 的计划已缩小，仅有 Parallel I/O，而研发团队也被裁员了。 Fortran的特性 　　 Fortran语言的最大特性是接近数学公式的自然描述，在计算机里具有很高的执行效率。 　　易学，语法严谨 。 　　可以直接对 矩阵 和复数进行运算，这一点类似matlab。 　　自诞生以来广泛地应用于 数值计算 领域， 积累了大量高效而可靠的源程序。 　　很多专用的大型数值运算计算机针对Fortran做了优化 。 　　 广泛地应用于 并行计算和高性能计算 领域 。 　　Fortran90，Fortran95，Fortran2003的相继推出使Fortran语言具备了现代高级 编程语言 的一些特性。 Fortran语言的Hello World程序 　　下面是一个在标准输出设备上使用Fortran90输出Hello World的简单程序，这种程序通常作为开始学习编程语言时的第一个程序： 　　program main 　　print *,'hello world' 　　end Fortran编译器 　　Windows操作系统下： 　　Fortran Power Station 4.0 (FPS 4.0)，微软公司开发的Fortran编译器。1997年3月转让给DEC公司。 　　Digital Visual Fortran (DVF)，Fortran Power Station的DEC公司版本。 　　Compaq Visual Fortran (CVF)，1998年1月，DEC公司被康柏公司收购，Digital Visual Fortran更名为Compaq Visual Fortran。一个著名的版本是Compaq Visual Fortran 6.5。目前康柏公司已并入 惠普公司 。Compaq Visual Fortran的最新版是6.6。 　　Intel Fortran，英特尔公司的开发的Fortran编译器。 　　Lahey Fortran 　　Absoft Fortran 　　OpenWatcom 　　 Linux操作系统 下： 　　PGI Fortran 　　G77，GNU的Fortran77编译器，集成在GCC中。 　　GFORTRAN，GNU的最新的Fortran编译器，集成在GCC 4.0中，目的是支持Fortran95和一部分Fortran2003的功能，以替代G77。 　　g95，跟GFORTRAN同为开放源代码的Fortran95编译器。 Fortran程序包 　　几个著名的Fortran程序包： 　　IMSL--国际 数学和统计 链接库 　　BLAS--Basic Linear Algebra Subroutines 　　LAPACK--Linear Algebra PACKage 　　FORTRAN90是ISO(国际标准化组织)于1991年 推出的最新标准 ,我国国家标准是GB/T 3057-1996.除了保持FORTRAN77的全部优点之外,又 增加了许多 具有现代特性的功能 ,使他成为 具有良好的结构特性 ,鲜明的时代特性的程序设计语言. 程序设计是计算机基础教育的基础与重点 ，高级语言程序设计课是继 微机 应用基础之后的一门必修的基础课， 目的是向学生介绍程序设计的基础知识，使学生掌握高级语言程序设计的基本方法，具有应用计算机的初步能力，并培养学生掌握用计算机处理问题的思维方法 。通过该课程的学习， 要求 学生了解FORTRAN语言的特点，基本成份及使用方法，具有阅读程序和初步编程的能力。进行算法的初步训练，掌握最基本算法的设计和实现方法。掌握结构化程序设计方法，能设计出良好风格的程序。具有调试程序的基本能力 。 Fortran的将来 　　 Fortran语言是一种极具发展潜力的语言，在全球范围内流行过程中，Fortran语言的 标准化 不断吸收现代化 编程语言 的新特性，并且在 工程计算领域 仍然占有重要地位。 　　不可否认，Fortran语言与目前流行的JAVA,C#等 高级语言 相比，它 缺乏创造力 。但是，工科学生必须注意到由于Fortran在工程计算领域 长期处于统治地位 ，很多优秀的工程计算 软件 都是运用fortran语言编写，例如ANSYS,Marc,为了能够使用这些商业软件的高级功能，必须先学会fortran语言，才能编写 应用程序接口 。 　　 在 数值计算 中，Fortran语言仍然 不可替代 。Fortran90标准引入了 数组计算 等非常利于 矩阵运算 的功能 。在 数组运算 时，Fortran能够自动进行 并行运算 ，这是很多编程语言不具备的。运用fortran语言 能够运用很多现成的函数 软件包 ，所以非常便利。（目前流行的Matlab的早期版本，主要就是为 两个著名的Fortran函数包 提供 程序接口 ）

个人分类: 直接形式化方法|2 次阅读|0 个评论

Programming language

geneculture 2012-6-26 23:31

http://www.webopedia.com/TERM/A/assembly_language.html Programming language Last updated 1 day ago From Wikipedia, the free encyclopedia Jump to: navigation , search Programming language lists Alphabetical Categorical Chronological Generational v · t · e A programming language is an artificial language designed to communicate instructions to a machine , particularly a computer . Programming languages can be used to create programs that control the behavior of a machine and/or to express algorithms precise ly . The earliest programming languages predate the invention of the computer , and were used to direct the behavior of machines such as Jacquard looms and player pianos . Thousands of different programming languages have been created , mainly in the computer field, with many more being created every year. Most programming languages describe computation in an imperative style, i.e., as a sequence of commands , although some languages , such as those that support functional programming or logic programming , use alternative forms of description . The description of a programming language is usually split into the two components of syntax (form) and semantics (meaning). Some languages are defined by a specification document (for example, the C programming language is specified by an ISO Standard), while other languages, such as Perl 5 and earlier, have a dominant implementation that is used as a reference . Contents 1 Definitions 2 Elements 2.1 Syntax 2.2 Semantics 2.2.1 Static semantics 2.2.2 Dynamic semantics 2.2.3 Type system 2.2.3.1 Typed versus untyped languages 2.2.3.2 Static versus dynamic typing 2.2.3.3 Weak and strong typing 2.3 Standard library and run-time system 3 Design and implementation 3.1 Specification 3.2 Implementation 4 Usage 4.1 Measuring language usage 5 Taxonomies 6 History 6.1 Early developments 6.2 Refinement 6.3 Consolidation and growth 7 See also 8 References 9 Further reading 10 External links Definitions A programming language is a notation for writing programs , which are specifications of a computation or algorithm . Some, but not all, authors re strict the term "programming language" to those languages that can express all possible algorithms. Traits often considered important for what constitutes a programming language include: Function and target : A computer programming language is a language used to write computer programs , which involve a computer performing some kind of computation or algorithm and possibly control external devices such as printers , disk drives , robots , and so on. For example PostScript programs are frequently created by another program to control a computer printer or display. More generally, a programming language may describe computation on some, possibly abstract, machine. It is generally accepted that a complete specification for a programming language includes a description, possibly idealized, of a machine or processor for that language. In most practical contexts, a programming language involves a computer; consequently, programming languages are usually defined and studied this way. Programming languages differ from natural languages in that natural languages are only used for interaction between people, while programming languages also allow humans to communicate instructions to machines. Abstractions : Programming languages usually contain abstractions for defining and manipulating data structures or controlling the flow of execution . The practical necessity that a programming language support adequate abstractions is expressed by the abstraction principle ; this principle is sometimes formulated as recommendation to the programmer to make proper use of such abstractions. Expressive power : The theory of computation classifies languages by the computations they are capable of expressing. All Turing complete languages can implement the same set of algorithms . ANSI/ISO SQL and Charity are examples of languages that are not Turing complete, yet often called programming languages. Markup languages like XML , HTML or troff , which define structured data , are not generally considered programming languages. Programming languages may, however, share the syntax with markup languages if a computational semantics is defined. XSLT , for example, is a Turing complete XML dialect. Moreover, LaTeX , which is mostly used for structuring documents, also contains a Turing complete subset. The term computer language is sometimes used interchangeably with programming language. However, the usage of both terms varies among authors, including the exact scope of each. One usage describes programming languages as a subset of computer languages. In this vein, languages used in computing that have a different goal than expressing computer programs are generically designated computer languages. For instance, markup languages are sometimes referred to as computer languages to emphasize that they are not meant to be used for programming. Another usage regards programming languages as theoretical constructs for programming abstract machines, and computer languages as the subset thereof that runs on physical computers, which have finite hardware resources. John C. Reynolds emphasizes that formal specification languages are just as much programming languages as are the languages intended for execution. He also argues that textual and even graphical input formats that affect the behavior of a computer are programming languages, despite the fact they are commonly not Turing-complete, and remarks that ignorance of programming language concepts is the reason for many flaws in input formats. Elements All programming languages have some primitive building blocks for the description of data and the processes or transformations applied to them (like the addition of two numbers or the selection of an item from a collection). These primitives are defined by syntactic and semantic rules which describe their structure and meaning respectively. Syntax Parse tree of Python code with inset tokenization Syntax highlighting is often used to aid programmers in recognizing elements of source code. The language above is Python . Main article: Syntax (programming languages) A programming language's surface form is known as its syntax . Most programming languages are purely textual; they use sequences of text including words, numbers, and punctuation, much like written natural languages. On the other hand, there are some programming languages which are more graphical in nature, using visual relationships between symbols to specify a program. The syntax of a language describes the possible combinations of symbols that form a syntactically correct program. The meaning given to a combination of symbols is handled by semantics (either formal or hard-coded in a reference implementation ). Since most languages are textual, this article discusses textual syntax. Programming language syntax is usually defined using a combination of regular expressions (for lexical structure) and Backus–Naur Form (for grammatical structure). Below is a simple grammar, based on Lisp : expression ::= atom | list atom ::= number | symbol number ::= ? + symbol ::= .* list ::= '(' expression* ')' This grammar specifies the following: an expression is either an atom or a list ; an atom is either a number or a symbol ; a number is an unbroken sequence of one or more decimal digits, optionally preceded by a plus or minus sign; a symbol is a letter followed by zero or more of any characters (excluding whitespace); and a list is a matched pair of parentheses, with zero or more expressions inside it. The following are examples of well-formed token sequences in this grammar: '12345', '()', '(a b c232 (1))' Not all syntactically correct programs are semantically correct. Many syntactically correct programs are nonetheless ill-formed, per the language's rules; and may (depending on the language specification and the soundness of the implementation) result in an error on translation or execution. In some cases, such programs may exhibit undefined behavior . Even when a program is well-defined within a language, it may still have a meaning that is not intended by the person who wrote it. Using natural language as an example, it may not be possible to assign a meaning to a grammatically correct sentence or the sentence may be false: " Colorless green ideas sleep furiously ." is grammatically well-formed but has no generally accepted meaning. "John is a married bachelor." is grammatically well-formed but expresses a meaning that cannot be true. The following C language fragment is syntactically correct, but performs operations that are not semantically defined (the operation *p 4 has no meaning for a value having a complex type and p-im is not defined because the value of p is the null pointer ): complex * p = NULL ; complex abs_p = sqrt ( * p 4 + p - im ) ; If the type declaration on the first line were omitted, the program would trigger an error on compilation, as the variable "p" would not be defined. But the program would still be syntactically correct, since type declarations provide only semantic information. The grammar needed to specify a programming language can be classified by its position in the Chomsky hierarchy . The syntax of most programming languages can be specified using a Type-2 grammar, i.e., they are context-free grammars . Some languages, including Perl and Lisp, contain constructs that allow execution during the parsing phase. Languages that have constructs that allow the programmer to alter the behavior of the parser make syntax analysis an undecidable problem , and generally blur the distinction between parsing and execution. In contrast to Lisp's macro system and Perl's BEGIN blocks, which may contain general computations, C macros are merely string replacements, and do not require code execution. Semantics The term Semantics refers to the meaning of languages, as opposed to their form ( syntax ). Static semantics The static semantics defines restrictions on the structure of valid texts that are hard or impossible to express in standard syntactic formalisms. For compiled languages, static semantics essentially include those semantic rules that can be checked at compile time. Examples include checking that every identifier is declared before it is used (in languages that require such declarations) or that the labels on the arms of a case statement are distinct. Many important restrictions of this type, like checking that identifiers are used in the appropriate context (e.g. not adding an integer to a function name), or that subroutine calls have the appropriate number and type of arguments, can be enforced by defining them as rules in a logic called a type system . Other forms of static analyses like data flow analysis may also be part of static semantics. Newer programming languages like Java and C# have definite assignment analysis , a form of data flow analysis, as part of their static semantics. Dynamic semantics Main article: Semantics of programming languages Once data has been specified, the machine must be instructed to perform operations on the data. For example, the semantics may define the strategy by which expressions are evaluated to values, or the manner in which control structures conditionally execute statements . The dynamic semantics (also known as execution semantics ) of a language defines how and when the various constructs of a language should produce a program behavior. There are many ways of defining execution semantics. Natural language is often used to specify the execution semantics of languages commonly used in practice. A significant amount of academic research went into formal semantics of programming languages , which allow execution semantics to be specified in a formal manner. Results from this field of research have seen limited application to programming language design and implementation outside academia. Type system Main articles: Data type , Type system , and Type safety A type system defines how a programming language classifies values and expressions into types , how it can manipulate those types and how they interact. The goal of a type system is to verify and usually enforce a certain level of correctness in programs written in that language by detecting certain incorrect operations. Any decidable type system involves a trade-off: while it rejects many incorrect programs, it can also prohibit some correct, albeit unusual programs. In order to bypass this downside, a number of languages have type loopholes , usually unchecked casts that may be used by the programmer to explicitly allow a normally disallowed operation between different types. In most typed languages, the type system is used only to type check programs, but a number of languages, usually functional ones, infer types , relieving the programmer from the need to write type annotations. The formal design and study of type systems is known as type theory . Typed versus untyped languages A language is typed if the specification of every operation defines types of data to which the operation is applicable, with the implication that it is not applicable to other types. For example, the data represented by "this text between the quotes" is a string . In most programming languages, dividing a number by a string has no meaning. Most modern programming languages will therefore reject any program attempting to perform such an operation. In some languages, the meaningless operation will be detected when the program is compiled ("static" type checking), and rejected by the compiler, while in others, it will be detected when the program is run ("dynamic" type checking), resulting in a runtime exception . A special case of typed languages are the single-type languages. These are often scripting or markup languages, such as REXX or SGML , and have only one data type—most commonly character strings which are used for both symbolic and numeric data. In contrast, an untyped language , such as most assembly languages , allows any operation to be performed on any data, which are generally considered to be sequences of bits of various lengths. High-level languages which are untyped include BCPL and some varieties of Forth . In practice, while few languages are considered typed from the point of view of type theory (verifying or rejecting all operations), most modern languages offer a degree of typing. Many production languages provide means to bypass or subvert the type system (see casting ). Static versus dynamic typing In static typing , all expressions have their types determined prior to when the program is executed, typically at compile-time. For example, 1 and (2+2) are integer expressions; they cannot be passed to a function that expects a string, or stored in a variable that is defined to hold dates. Statically typed languages can be either manifestly typed or type-inferred . In the first case, the programmer must explicitly write types at certain textual positions (for example, at variable declarations ). In the second case, the compiler infers the types of expressions and declarations based on context. Most mainstream statically typed languages, such as C++ , C# and Java , are manifestly typed. Complete type inference has traditionally been associated with less mainstream languages, such as Haskell and ML . However, many manifestly typed languages support partial type inference; for example, Java and C# both infer types in certain limited cases. Dynamic typing , also called latent typing , determines the type-safety of operations at runtime; in other words, types are associated with runtime values rather than textual expressions . As with type-inferred languages, dynamically typed languages do not require the programmer to write explicit type annotations on expressions. Among other things, this may permit a single variable to refer to values of different types at different points in the program execution. However, type errors cannot be automatically detected until a piece of code is actually executed, potentially making debugging more difficult. Lisp , Perl , Python , JavaScript , and Ruby are dynamically typed. Weak and strong typing Weak typing allows a value of one type to be treated as another, for example treating a string as a number. This can occasionally be useful, but it can also allow some kinds of program faults to go undetected at compile time and even at run-time . Strong typing prevents the above. An attempt to perform an operation on the wrong type of value raises an error. Strongly typed languages are often termed type-safe or safe . An alternative definition for "weakly typed" refers to languages, such as Perl and JavaScript , which permit a large number of implicit type conversions. In JavaScript, for example, the expression 2 * x implicitly converts x to a number, and this conversion succeeds even if x is null, undefined, an Array, or a string of letters. Such implicit conversions are often useful, but they can mask programming errors. Strong and static are now generally considered orthogonal concepts, but usage in the literature differs. Some use the term strongly typed to mean strongly, statically typed , or, even more confusingly, to mean simply statically typed . Thus C has been called both strongly typed and weakly, statically typed. Standard library and run-time system Main article: Standard library Most programming languages have an associated core library (sometimes known as the 'standard library', especially if it is included as part of the published language standard), which is conventionally made available by all implementations of the language. Core libraries typically include definitions for commonly used algorithms, data structures, and mechanisms for input and output. A language's core library is often treated as part of the language by its users, although the designers may have treated it as a separate entity. Many language specifications define a core that must be made available in all implementations, and in the case of standardized languages this core library may be required. The line between a language and its core library therefore differs from language to language. Indeed, some languages are designed so that the meanings of certain syntactic constructs cannot even be described without referring to the core library. For example, in Java , a string literal is defined as an instance of the java.lang.String class; similarly, in Smalltalk , an anonymous function expression (a "block") constructs an instance of the library's BlockContext class. Conversely, Scheme contains multiple coherent subsets that suffice to construct the rest of the language as library macros, and so the language designers do not even bother to say which portions of the language must be implemented as language constructs, and which must be implemented as parts of a library. Design and implementation Programming languages share properties with natural languages related to their purpose as vehicles for communication, having a syntactic form separate from its semantics, and showing language families of related languages branching one from another. But as artificial constructs, they also differ in fundamental ways from languages that have evolved through usage. A significant difference is that a programming language can be fully described and studied in its entirety, since it has a precise and finite definition. By contrast, natural languages have changing meanings given by their users in different communities. While constructed languages are also artificial languages designed from the ground up with a specific purpose, they lack the precise and complete semantic definition that a programming language has. Many programming languages have been designed from scratch, altered to meet new needs, and combined with other languages. Many have eventually fallen into disuse. Although there have been attempts to design one "universal" programming language that serves all purposes, all of them have failed to be generally accepted as filling this role. The need for diverse programming languages arises from the diversity of contexts in which languages are used: Programs range from tiny scripts written by individual hobbyists to huge systems written by hundreds of programmers . Programmers range in expertise from novices who need simplicity above all else, to experts who may be comfortable with considerable complexity. Programs must balance speed, size, and simplicity on systems ranging from microcontrollers to supercomputers . Programs may be written once and not change for generations, or they may undergo continual modification. Finally, programmers may simply differ in their tastes: they may be accustomed to discussing problems and expressing them in a particular language. One common trend in the development of programming languages has been to add more ability to solve problems using a higher level of abstraction . The earliest programming languages were tied very closely to the underlying hardware of the computer. As new programming languages have developed, features have been added that let programmers express ideas that are more remote from simple translation into underlying hardware instructions. Because programmers are less tied to the complexity of the computer, their programs can do more computing with less effort from the programmer. This lets them write more functionality per time unit. Natural language processors have been proposed as a way to eliminate the need for a specialized language for programming. However, this goal remains distant and its benefits are open to debate. Edsger W. Dijkstra took the position that the use of a formal language is essential to prevent the introduction of meaningless constructs, and dismissed natural language programming as "foolish". Alan Perlis was similarly dismissive of the idea. Hybrid approaches have been taken in Structured English and SQL . A language's designers and users must construct a number of artifacts that govern and enable the practice of programming. The most important of these artifacts are the language specification and implementation . Specification Main article: Programming language specification The specification of a programming language is intended to provide a definition that the language users and the implementors can use to determine whether the behavior of a program is correct, given its source code . A programming language specification can take several forms, including the following: An explicit definition of the syntax, static semantics, and execution semantics of the language. While syntax is commonly specified using a formal grammar, semantic definitions may be written in natural language (e.g., as in the C language ), or a formal semantics (e.g., as in Standard ML and Scheme specifications). A description of the behavior of a translator for the language (e.g., the C++ and Fortran specifications). The syntax and semantics of the language have to be inferred from this description, which may be written in natural or a formal language. A reference or model implementation , sometimes written in the language being specified (e.g., Prolog or ANSI REXX ). The syntax and semantics of the language are explicit in the behavior of the reference implementation. Implementation Main article: Programming language implementation An implementation of a programming language provides a way to execute that program on one or more configurations of hardware and software. There are, broadly, two approaches to programming language implementation: compilation and interpretation . It is generally possible to implement a language using either technique. The output of a compiler may be executed by hardware or a program called an interpreter. In some implementations that make use of the interpreter approach there is no distinct boundary between compiling and interpreting. For instance, some implementations of BASIC compile and then execute the source a line at a time. Programs that are executed directly on the hardware usually run several orders of magnitude faster than those that are interpreted in software. One technique for improving the performance of interpreted programs is just-in-time compilation . Here the virtual machine , just before execution, translates the blocks of bytecode which are going to be used to machine code, for direct execution on the hardware. Usage Thousands of different programming languages have been created, mainly in the computing field. Programming languages differ from most other forms of human expression in that they require a greater degree of precision and completeness. When using a natural language to communicate with other people, human authors and speakers can be ambiguous and make small errors, and still expect their intent to be understood. However, figuratively speaking, computers "do exactly what they are told to do", and cannot "understand" what code the programmer intended to write. The combination of the language definition, a program, and the program's inputs must fully specify the external behavior that occurs when the program is executed, within the domain of control of that program. On the other hand, ideas about an algorithm can be communicated to humans without the precision required for execution by using pseudocode , which interleaves natural language with code written in a programming language. A programming language provides a structured mechanism for defining pieces of data, and the operations or transformations that may be carried out automatically on that data. A programmer uses the abstractions present in the language to represent the concepts involved in a computation. These concepts are represented as a collection of the simplest elements available (called primitives ). Programming is the process by which programmers combine these primitives to compose new programs, or adapt existing ones to new uses or a changing environment. Programs for a computer might be executed in a batch process without human interaction, or a user might type commands in an interactive session of an interpreter . In this case the "commands" are simply programs, whose execution is chained together. When a language is used to give commands to a software application (such as a shell ) it is called a scripting language . Measuring language usage Main article: Measuring programming language popularity It is difficult to determine which programming languages are most widely used, and what usage means varies by context. One language may occupy the greater number of programmer hours, a different one have more lines of code, and a third utilize the most CPU time. Some languages are very popular for particular kinds of applications. For example, COBOL is still strong in the corporate data center, often on large mainframes ; Fortran in scientific and engineering applications; and C in embedded applications and operating systems. Other languages are regularly used to write many different kinds of applications. Various methods of measuring language popularity, each subject to a different bias over what is measured, have been proposed: counting the number of job advertisements that mention the language the number of books sold that teach or describe the language estimates of the number of existing lines of code written in the language—which may underestimate languages not often found in public searches counts of language references (i.e., to the name of the language) found using a web search engine. Combining and averaging information from various internet sites, langpop.com claims that in 2008 the 10 most cited programming languages are (in alphabetical order): C , C++ , C# , Java , JavaScript , Perl , PHP , Python , Ruby , and SQL . Taxonomies For more details on this topic, see Categorical list of programming languages . There is no overarching classification scheme for programming languages. A given programming language does not usually have a single ancestor language. Languages commonly arise by combining the elements of several predecessor languages with new ideas in circulation at the time. Ideas that originate in one language will diffuse throughout a family of related languages, and then leap suddenly across familial gaps to appear in an entirely different family. The task is further complicated by the fact that languages can be classified along multiple axes. For example, Java is both an object-oriented language (because it encourages object-oriented organization) and a concurrent language (because it contains built-in constructs for running multiple threads in parallel). Python is an object-oriented scripting language . In broad strokes, programming languages divide into programming paradigms and a classification by intended domain of use . Traditionally, programming languages have been regarded as describing computation in terms of imperative sentences, i.e. issuing commands. These are generally called imperative programming languages. A great deal of research in programming languages has been aimed at blurring the distinction between a program as a set of instructions and a program as an assertion about the desired answer, which is the main feature of declarative programming . More refined paradigms include procedural programming , object-oriented programming , functional programming , and logic programming ; some languages are hybrids of paradigms or multi-paradigmatic. An assembly language is not so much a paradigm as a direct model of an underlying machine architecture. By purpose, programming languages might be considered general purpose, system programming languages, scripting languages, domain-specific languages, or concurrent/distributed languages (or a combination of these). Some general purpose languages were designed largely with educational goals. A programming language may also be classified by factors unrelated to programming paradigm. For instance, most programming languages use English language keywords, while a minority do not . Other languages may be classified as being deliberately esoteric or not. History A selection of textbooks that teach programming, in languages both popular and obscure. These are only a few of the thousands of programming languages and dialects that have been designed in history. Main articles: History of programming languages and Programming language generations Early developments The first programming languages predate the modern computer. The 19th century saw the invention of "programmable" looms and player piano scrolls, both of which implemented examples of domain-specific languages . By the beginning of the twentieth century, punch cards encoded data and directed mechanical processing. In the 1930s and 1940s, the formalisms of Alonzo Church 's lambda calculus and Alan Turing 's Turing machines provided mathematical abstractions for expressing algorithms ; the lambda calculus remains influential in language design. In the 1940s, the first electrically powered digital computers were created. The first high-level programming language to be designed for a computer was Plankalkül , developed for the German Z3 by Konrad Zuse between 1943 and 1945. However, it was not implemented until 1998 and 2000. Programmers of early 1950s computers, notably UNIVAC I and IBM 701 , used machine language programs , that is, the first generation language (1GL). 1GL programming was quickly superseded by similarly machine-specific, but mnemonic , second generation languages (2GL) known as assembly languages or "assembler". Later in the 1950s, assembly language programming, which had evolved to include the use of macro instructions , was followed by the development of "third generation" programming languages (3GL), such as FORTRAN , LISP , and COBOL . 3GLs are more abstract and are "portable", or at least implemented similarly on computers that do not support the same native machine code. Updated versions of all of these 3GLs are still in general use, and each has strongly influenced the development of later languages. At the end of the 1950s, the language formalized as ALGOL 60 was introduced, and most later programming languages are, in many respects, descendants of Algol. The format and use of the early programming languages was heavily influenced by the constraints of the interface . Refinement The period from the 1960s to the late 1970s brought the development of the major language paradigms now in use, though many aspects were refinements of ideas in the very first Third-generation programming languages : APL introduced array programming and influenced functional programming . PL/I (NPL) was designed in the early 1960s to incorporate the best ideas from FORTRAN and COBOL. In the 1960s, Simula was the first language designed to support object-oriented programming ; in the mid-1970s, Smalltalk followed with the first "purely" object-oriented language. C was developed between 1969 and 1973 as a system programming language, and remains popular. Prolog , designed in 1972, was the first logic programming language. In 1978, ML built a polymorphic type system on top of Lisp, pioneering statically typed functional programming languages. Each of these languages spawned an entire family of descendants, and most modern languages count at least one of them in their ancestry. The 1960s and 1970s also saw considerable debate over the merits of structured programming , and whether programming languages should be designed to support it. Edsger Dijkstra , in a famous 1968 letter published in the Communications of the ACM , argued that GOTO statements should be eliminated from all "higher level" programming languages. The 1960s and 1970s also saw expansion of techniques that reduced the footprint of a program as well as improved productivity of the programmer and user. The card deck for an early 4GL was a lot smaller for the same functionality expressed in a 3GL deck . Consolidation and growth The 1980s were years of relative consolidation. C++ combined object-oriented and systems programming. The United States government standardized Ada , a systems programming language derived from Pascal and intended for use by defense contractors. In Japan and elsewhere, vast sums were spent investigating so-called "fifth generation" languages that incorporated logic programming constructs. The functional languages community moved to standardize ML and Lisp. Rather than inventing new paradigms, all of these movements elaborated upon the ideas invented in the previous decade. One important trend in language design for programming large-scale systems during the 1980s was an increased focus on the use of modules , or large-scale organizational units of code. Modula-2 , Ada, and ML all developed notable module systems in the 1980s, although other languages, such as PL/I , already had extensive support for modular programming. Module systems were often wedded to generic programming constructs. The rapid growth of the Internet in the mid-1990s created opportunities for new languages. Perl , originally a Unix scripting tool first released in 1987, became common in dynamic websites . Java came to be used for server-side programming, and bytecode virtual machines became popular again in commercial settings with their promise of " Write once, run anywhere " ( UCSD Pascal had been popular for a time in the early 1980s). These developments were not fundamentally novel, rather they were refinements to existing languages and paradigms, and largely based on the C family of programming languages. Programming language evolution continues, in both industry and research. Current directions include security and reliability verification, new kinds of modularity ( mixins , delegates , aspects ), and database integration such as Microsoft's LINQ . The 4GLs are examples of languages which are domain-specific, such as SQL , which manipulates and returns sets of data rather than the scalar values which are canonical to most programming languages. Perl , for example, with its ' here document ' can hold multiple 4GL programs, as well as multiple JavaScript programs, in part of its own perl code and use variable interpolation in the 'here document' to support multi-language programming. http://en.wikipedia.org/wiki/Programming_language

个人分类: 软件工程|1 次阅读|0 个评论

Google的Go语言编程

热度 1 ChinaAbel 2012-5-13 18:56

Go的定位是系统编程，比如Web服务器、存储系统和数据库等，但也欢迎在其它方面的应用。据Google官方的消息，该语言还有望被用于其它领域。现在Google终于在其 官方博客宣 布Go语言首个稳定版本发布，这也标志着第一个原生支持Windows用户的自然语言发布。Google发布稳定版本的目的是给开发者的开发提供一个固定的努力目标。直到现在，该语言仍发生着定期改变，有些可能与现有代码完全不同。从现在开始，除非必要，Google工程师将确保新特性与已有特性兼容。Go语言的很大一部分灵感来源于C语言，同时对像Pascal、Newsqueak和Limbo这样的语言也有借鉴。Go语言定位于系统程序开发，具有简洁、快速、安全、并行、有趣、开源等特色。同时支持泛型编程，内存管理，数组安全，编译迅速。同时发布的包括Go 编程语言、官方库和工具集的 1.0 稳定版本。同步开发的 GAE 团队也同步发布 1.6.4 版的Google App Engine SDK for the Go runtime，提供对新版GO语言的支持。 闲话少说，还是先来段代码过过瘾吧，哈哈！ 简单的Hello World程序： package mainimport "fmt"//Package implementing formatted I/O. func main() {fmt.Printf("Hello, 世界\n")} 在这里我也给出一些学习Go语言的材料共各位需要了解Go语言的博友参考。（均来自网上，无版权，请勿商用！） 1. go(Google)语言精要.pdf 2. 《Google_Go：初级读本》.pdf 3. google的Go语言编程.pdf 4. Effective_Go.pdf （未完待续）

个人分类: 计算机&大数据|9080 次阅读|1 个评论

[转载]2012年5月编程语言排行榜：C再次位居第一， Java持续下挫

chnfirst 2012-5-11 16:31

http://tech.huanqiu.com/Soft/2012-05/2709285.html 2012年5月编程语言排行榜：C再次位居第一， Java 持续下挫 2012-05-10 08:49 cnBeta 请快来参与 分享到： 0 摘要： Java 自从上个月丢掉第一个的宝座以后，这个月的的走势依然下挫。及时把这个因素考虑进去，也没有任何新的语言表现出持续上升的势态。让我看一些例子，例如 Scala ，它目前是第48位，当我们在2006年开始注意到这个语言的时候，它的排名是57。 　　Java 自从上个月丢掉第一个的宝座以后，这个月的的走势依然下挫。在过去8年中，前10名的编程语言几乎没有变化，支持 Objective-C 把 Delphi 给挤了出去。人们对新语言的接受程度进展缓慢，这很有可能是由于遗留系统难以迁移导致的。及时把这个因素考虑进去，也没有任何新的语言表现出持续上升的势态。 　　 谁会是下一个明星编程语言呢？ 　　让我看一些例子，例如 Scala ，它目前是第48位，当我们在2006年开始注意到这个语言的时候，它的排名是57。看起来上涨不多，但是即使这么小的涨幅也没有发生在其他语言身上，例如 F#（2012:#40,2006:#38），Groovy（2012:#32,2008:36），Erlang （2012:#44,2006:#35）还有 Clojure（2012:#77,2009:#88）。你认为谁最有潜力？ 　　以下是各个语言的长期走势图： （责任编辑：陈健）

个人分类: 电脑、办公|0 个评论

[转载]流式计算之Storm简介[转载]

qhhuangscut 2012-3-8 16:51

本文转载于 http://blog.sina.com.cn/s/blog_406d9bb00100ui5p.html 【关注点】随着越来越多监测设备的部署，如PMUs, 变电站里面的智能终端，电力系统将面临大规模实时信息流处理的需要，流计算和事务处理将有可能比应用到电力系统中（相关的计算在IT业应该算是比较成熟了） Storm是一个分布式的、容错的实时计算系统，遵循Eclipse Public License 1.0,Storm可以方便地在一个计算机集群中编写与扩展复杂的实时计算，Storm之于实时处理，就好比Hadoop之于批处理。Storm保证每个消息都会得到处理，而且它很快——在一个小集群中，每秒可以处理数以百万计的消息。可以使用任意编程语言来做开发。 主要商业应用及案例：Twitter Storm的优点 1. 简单的编程模型。类似于MapReduce降低了并行批处理复杂性，Storm降低了进行实时处理的复杂性。 2. 服务化,一个服务框架,支持热部署,即时上线或下线App. 3. 可以使用各种编程语言。你可以在Storm之上使用各种编程语言。默认支持Clojure、Java、Ruby和Python。要增加对其他语言的支持，只需实现一个简单的Storm通信协议即可。 4. 容错性。Storm会管理工作进程和节点的故障。 5. 水平扩展。计算是在多个线程、进程和服务器之间并行进行的。 6. 可靠的消息处理。Storm保证每个消息至少能得到一次完整处理。任务失败时，它会负责从消息源重试消息。 7. 快速。系统的设计保证了消息能得到快速的处理，使用ZeroMQ作为其底层消息队列。 8. 本地模式。Storm有一个“本地模式”，可以在处理过程中完全模拟Storm集群。这让你可以快速进行开发和单元测试。 Storm目前存在的问题 1. 目前的开源版本中只是单节点 Nimbus ，挂掉只能自动重启，可以考虑实现一个双 nimbus 的布局。 2. Clojure 是一个在 JVM 平台运行的动态函数式编程语言 , 优势在于流程计算， Storm 的部分核心内容由 Clojure 编写，虽然性能上提高不少但同时也提升了维护成本。 Storm 架构 Storm 集群由一个主节点和多个工作节点组成。主节点运行了一个名为 “Nimbus” 的守护进程，用于分配代码、布置任务及故障检测。每个工作节点都运行了一个名为 “Supervisor” 的守护进程，用于监听工作，开始并终止工作进程。 Nimbus 和 Supervisor 都能快速失败，而且是无状态的，这样一来它们就变得十分健壮，两者的协调工作是由 Zookeeper 来完成的。 ZooKeeper 用于管理集群中的不同组件， ZeroMQ 是内部消息系统， JZMQ 是 ZeroMQMQ 的 Java Binding 。有个名为 storm-deploy 的子项目，可以在 AWS 上一键部署 Storm 集群 . Storm 术语解释 Storm 的术语包括 Stream 、 Spout 、 Bolt 、 Task 、 Worker 、 Stream Grouping 和 Topology 。 Stream 是被处理的数据。 Sprout 是数据源。 Bolt 处理数据。 Task 是运行于 Spout 或 Bolt 中的 线程。 Worker 是运行这些线程的进程。 Stream Grouping 规定了 Bolt 接收什么东西作为输入数据。数据可以随机分配（术语为 Shuffle ），或者根据字段值分配（术语为 Fields ），或者 广播（术语为 All ），或者总是发给一个 Task （术语为 Global ），也可以不关心该数据（术语为 None ），或者由自定义逻辑来决定（术语为 Direct ）。 Topology 是由 Stream Grouping 连接起来的 Spout 和 Bolt 节点网络 . 下面进行详细介绍： Topologies 用于封装一个实时计算应用程序的逻辑，类似于 Hadoop 的 MapReduce Job Stream 消息流，是一个没有边界的 tuple 序列，这些 tuples 会被以一种分布式的方式并行地创建和处理 Spouts 消息源，是消息生产者，他会从一个外部源读取数据并向 topology 里面面发出消息： tuple Bolts 消息处理者，所有的消息处理逻辑被封装在 bolts 里面，处理输入的数据流并产生输出的新数据流 , 可执行过滤，聚合，查询数据库等操作 Task 每一个 Spout 和 Bolt 会被当作很多 task 在整个集群里面执行 , 每一个 task 对应到一个线程 . Stream groupings 消息分发策略 , 定义一个 Topology 的其中一步是定义每个 tuple 接受什么样的流作为输入 ,stream grouping 就是用来定义一个 stream 应该如果分配给 Bolts 们 . stream grouping 分类 1. Shuffle Grouping: 随机分组， 随机派发 stream 里面的 tuple ， 保证每个 bolt 接收到的 tuple 数目相同 . 2. Fields Grouping ：按字段分组， 比如按 userid 来分组， 具有同样 userid 的 tuple 会被分到相同的 Bolts ， 而不同的 userid 则会被分配到不同的 Bolts. 3. All Grouping ： 广播发送， 对于每一个 tuple ， 所有的 Bolts 都会收到 . 4. Global Grouping: 全局分组，这个 tuple 被分配到 storm 中的一个 bolt 的其中一个 task. 再具体一点就是分配给 id 值最低的那个 task. 5. Non Grouping: 不分组，意思是说 stream 不关心到底谁会收到它的 tuple. 目前他和 Shuffle grouping 是一样的效果 , 有点不同的是 storm 会把这个 bolt 放到这个 bolt 的订阅者同一个线程去执行 . 6. Direct Grouping: 直接分组 , 这是一种比较特别的分组方法，用这种分组意味着消息的发送者举鼎由消息接收者的哪个 task 处理这个消息 . 只有被声明为 Direct Stream 的消息流可以声明这种分组方法 . 而且这种消息 tuple 必须使用 emitDirect 方法来发射 . 消息处理者可以通过 TopologyContext 来或者处理它的消息的 taskid (OutputCollector.emit 方法也会返回 taskid) Storm 如何保证消息被处理 storm 保证每个 tuple 会被 topology 完整的执行。 storm 会追踪由每个 spout tuple 所产生的 tuple 树 ( 一个 bolt 处理一个 tuple 之后可能会发射别的 tuple 从而可以形成树状结构 ), 并且跟踪这棵 tuple 树什么时候成功处理完。每个 topology 都有一个消息超时的设置， 如果 storm 在这个超时的时间内检测不到某个 tuple 树到底有没有执行成功， 那么 topology 会把这个 tuple 标记为执行失败，并且过一会会重新发射这个 tuple 。 一个 tuple 能根据新获取到的 spout 而触发创建基于此的上千个 tuple TopologyBuilder builder = new TopologyBuilder(); builder.setSpout(1, new KestrelSpout("kestrel.backtype.com", 22133, "sentence_queue", new StringScheme())); builder.setBolt(2, new SplitSentence(), 10) .shuffleGrouping(1); builder.setBolt(3, new WordCount(), 20) .fieldsGrouping(2, new Fields("word")); 这个 topology 从 kestrel queue 读取句子 , 并把句子划分成单词 , 然后汇总每个单词出现的次数 , 一个 tuple 负责读取句子 , 每一个 tuple 分别对应计算每一个单词出现的次数 , 大概样子如下所示 : 一个 tuple 的生命周期 : public interface ISpout extends Serializable { void open(Map conf, TopologyContext context, SpoutOutputCollector collector); void close(); void nextTuple(); void ack(Object msgId); void fail(Object msgId); } 首先 storm 通过调用 spout 的 nextTuple 方法来获取下一个 tuple, Spout 通过 open 方法参数里面提供的 SpoutOutputCollector 来发射新 tuple 到它的其中一个输出消息流 , 发射 tuple 的时候 spout 会提供一个 message-id, 后面我们通过这个 tuple-id 来追踪这个 tuple 。举例来说， KestrelSpout 从 kestrel 队列里面读取一个消息，并且把 kestrel 提供的消息 id 作为 message-id, 看例子： collector.emit(new Values("field1", "field2", 3) , msgId); 接下来， 这个发射的 tuple 被传送到消息处理者 bolt 那里， storm 会跟踪这个消息的树形结构是否创建 , 根据 messageid 调用 Spout 里面的 ack 函数以确认 tuple 是否被完全处理。如果 tuple 超时就会调用 spout 的 fail 方法。由此看出同一个 tuple 不管是 acked 还是 fail 都是由创建他的那个 spout 发出的 , 所以即使 spout 在集群环境中执行了很多的 task, 这个 tule 也不会被不同的 task 去 acked 或 failed. 当 kestrelspout 从 kestrel 队列中得到一个消息后会打开这个他 , 这意味着他并不会把此消息拿走 , 消息的状态会显示为 pending, 直到等待确认此消息已经处理完成 , 处于 pending 状态直到 ack 或者 fail 被调用 , 处于 "Pending" 的消息不会再被其他队列消费者使用 . 如果在这过程中 spout 中处理此消息的 task 断开连接或失去响应则此 pending 的消息会回到 " 等待处理 " 状态 . Storm 的一些常用应用场景 1. 流聚合 流聚合把两个或者多个数据流聚合成一个数据流 — 基于一些共同的 tuple 字段。 builder.setBolt(5, new MyJoiner(), parallelism) .fieldsGrouping(1, new Fields("joinfield1", "joinfield2")) .fieldsGrouping(2, new Fields("joinfield1", "joinfield2")) .fieldsGrouping(3, new Fields("joinfield1", "joinfield2")) 2. 批处理 有时候为了性能或者一些别的原因， 你可能想把一组 tuple 一起处理， 而不是一个个单独处理。 3.BasicBolt 1. 读一个输入 tuple 2. 根据这个输入 tuple 发射一个或者多个 tuple 3. 在 execute 的方法的最后 ack 那个输入 tuple 遵循这类模式的 bolt 一般是函数或者是过滤器 , 这种模式太常见， storm 为这类模式单独封装了一个接口 : IbasicBolt 4. 内存内缓存 +Fields grouping 组合 在 bolt 的内存里面缓存一些东西非常常见。缓存在和 fields grouping 结合起来之后就更有用了。比如，你有一个 bolt 把短链接变成长链接 (bit.ly, t.co 之类的 ) 。你可以把短链接到长链接的对应关系利用 LRU 算法缓存在内存里面以避免重复计算。比如组件一发射短链接，组件二把短链接转化成长链接并缓存在内存里面。看一下下面两段代码有什么不一样： builder.setBolt(2, new ExpandUrl(), parallelism) .shuffleGrouping(1); builder.setBolt(2, new ExpandUrl(), parallelism) .fieldsGrouping(1, new Fields("url")); 5. 计算 top N 比如你有一个 bolt 发射这样的 tuple: "value", "count" 并且你想一个 bolt 基于这些信息算出 top N 的 tuple 。最简单的办法是有一个 bolt 可以做一个全局的 grouping 的动作并且在内存里面保持这 top N 的值。 这个方式对于大数据量的流显然是没有扩展性的， 因为所有的数据会被发到同一台机器。一个更好的方法是在多台机器上面并行的计算这个流每一部分的 top N, 然后再有一个 bolt 合并这些机器上面所算出来的 top N 以算出最后的 top N, 代码大概是这样的 : builder.setBolt(2, new RankObjects(), parallellism) .fieldsGrouping(1, new Fields("value")); builder.setBolt(3, new MergeObjects()) .globalGrouping(2); 这个模式之所以可以成功是因为第一个 bolt 的 fields grouping 使得这种并行算法在语义上是正确的。 用 TimeCacheMap 来高效地保存一个最近被更新的对象的缓存 6. 用 TimeCacheMap 来高效地保存一个最近被更新的对象的缓存 有时候你想在内存里面保存一些最近活跃的对象，以及那些不再活跃的对象。 TimeCacheMap 是一个非常高效的数据结构，它提供了一些 callback 函数使得我们在对象不再活跃的时候我们可以做一些事情 . 7. 分布式 RPC:CoordinatedBolt 和 KeyedFairBolt 用 storm 做分布式 RPC 应用的时候有两种比较常见的模式 : 它们被封装在 CoordinatedBolt 和 KeyedFairBolt 里面 . CoordinatedBolt 包装你的 bolt, 并且确定什么时候你的 bolt 已经接收到所有的 tuple, 它主要使用 Direct Stream 来做这个 . KeyedFairBolt 同样包装你的 bolt 并且保证你的 topology 同时处理多个 DRPC 调用，而不是串行地一次只执行一个。

个人分类: TechZone|4382 次阅读|0 个评论

嘉文请进！实例讨论。

热度 1 geneculture 2011-11-15 17:08

我是这样想的： 1.C和C++的同类示例或实例比比皆是，如何选择几组有说服力的案例并能用较少的文字和图表加以转述和点评？这也是一种能力。这样的学习和锻炼的机会，学习者最好不要简单地一带而过！换一句话说，作者要站在读者立场上来想一想：别人读了我的文章究竟能从中得到什么新的启示或帮助？ 2.如何采用对称矩阵的方式和双语编程的策略来调用和重组从上述比比皆是的C和C++的同类示例或实例中选择的几组有说服力的案例？具体做法多种多样——我曾经在多种场合并以多个角度介绍过。 记住 Kurt Lewin 的话：“ 没有什么比一个好的理论更实用了 。” 一个好的理论使得学习和开发你的知识更容易，而不会带来过分的崇拜。这将是聪明的。 http://edu.qq.com/a/20101118/000174_2.htm geneculture 2011-11-15 16:57 就用一个五子棋做例子， 这样也许更能说明问题。 附录： geneculture 2011-11-15 16:53 我们在 做的对照实例 中就有： 0.汇编语言 1.结构化编程语言 2.对象化编程语言 以上是第一路径的做法 ， 以下是第二路径的做法 ： 3.对称矩阵方式+双语调用机制= 最终是双重路径协同的效果 ： 第二路径的用户 仅需在前台采用“母语+对象”进行操作 双重路径的系统 即可在后台 支持 调用或重组“数据结构+算法”加以响应 （这 对第二路径的用户来说 也就相当于 用户无须懂第一路径的任何编程语言 就可直接采用“母语+对象”的操作方式 进行特定的个性化编程或标准化类库的 调用或重组） 【84】 geneculture 2011-11-15 16:40 e.g.1 你想要看的那些个简单的示例，如：计算示例的“hello world!”，在新框架中是这样实现的： 步骤1：用户只要用母语把“你好！”（等价于“Hello”或“hello world”）和一个“对象”界面用鼠标拉在一起， 步骤2：再按一个运行模式调用按键 步骤3：即可完成。具体表现为：用户点击--机器运行。 注： 在新框架（“前台仅可用母语的多语种自由切换开发环境”）的双语标注对象类库中选择进入“（简单）调用”（不懂任何编程语言的普通用户）或“（精心）重构或重组”（至少精通某种编程语言的高级用户），本例进入前一个入口，即可看见一个具体的子类库，用户便可从中选择某个“双语标注对象”，本例就是步骤1所述的情形，然后，再选择“（简单）调用”，本例即步骤2，步骤3实际上已经是验证者点击--软件运行回应。 博主回复(2011-11-15 17:08) ： 这样好吧，我把传统只用第一路径实现加法操作语义的架构和过程展现出来。晓辉基于这个架构和过程对照说明你的第二路径是如何参与进来工作，是可以如何更便捷解决更复杂的问题的（可以故意复杂化加法操作语义的问题，以便展现第二路径的优势）。 博主回复(2011-11-15 16:51) ： 我现在需要晓辉展示的是：做一个具体的计算操作。这个计算操作，一定要使用到晓辉的序位矩阵、孪生图灵机等架构元素，还要看到在什么扩展点或聚拢点与第一路径的架构交汇。 博主回复(2011-11-15 16:47) ： 关键是要展现你的架构的关键特征，而不是实现一个简单的示例，因此，可能需要将简单的示例复杂化，以便这个示例可以用来表现你的架构机制的优势。 【83】 geneculture 2011-11-15 16:19 不要说设计做一个加法了， 就是设计做计算器、象棋、写字板、浏览器、视窗、信息管理系统、计算机辅助教学系统、计算机辅助决策系统、多种编程语言协作开发平台、前台仅可用母语的多语种自由切换开发环境，等等，都不在话下。 你想要看的那些个简单的示例，如：计算示例的“hello world!”，用户只要用母语把它（即：“你好！”）和一个“对象”界面用鼠标落在一起，再按一个运行模式调用按键即可完成。换句话说，对第二路径的普通用户几乎就是无须使用以往的任何编程语言就实际是在做第一路径需要编程的事情了。 博主回复(2011-11-15 16:37) ： 不是让晓辉实现我这个示例，是让晓辉模仿设计和实现自己的示例。这种示例测试着设计，是我认为是一种非常有效的架构设计方法。 博主回复(2011-11-15 16:34) ： 案例可参考我的基因软件架构设计的“计算者”系列示例。 http://blog.sciencenet.cn/home.php?mod=spaceuid=33982do=blogid=405882 博主回复(2011-11-15 16:29) ： 晓辉需要在示例中展示你的每一个架构的特性。 博主回复(2011-11-15 16:28) ： 晓辉明显轻视了这个任务。何不写篇博文沙盘演示一下？ 【82】 geneculture 2011-11-15 16:06 补充2： 图11是该虚拟云操作系统第二层c 界面示意图。 由图11 可知，云操作系统第二层c 界面属于“物”的范畴，也具有可间接计算的特点。即：具有“三多”功能或机助人的环境。 注：“三多”即：多媒体（呈现方式）、多学科（知识背景）、多语种（语言支撑）。 博主回复(2011-11-15 16:25) ： 也就是说，你可以把一个加法操作设计得是非常难以执行到的操作，用传统的第一路径如何实现这个操作语义的端对端贯通，而在加入第二路径之后，又是怎样贯通的。即便这么简单的问题，用第二路径来解决可能反而显得更累赘和啰嗦，也是可以理解的，只要机制是通的，我总能找到这些累赘的机制对于更复杂的问题而言，是必要的的道理。 所以，晓辉没有理由举不出这样的例子。我对我自己的基因软件架构，就是使用这个方法来测试的。 博主回复(2011-11-15 16:16) ： 只有这种实在的、事实化的论述，才会激起读者的兴趣和勤奋欲。 博主回复(2011-11-15 16:14) ： 要证明操作语义的实现机制很简单，请设想在新架构下，可以把一个加法实现为什么样子？尽量充分利用到你的每个架构特征，也许这样的加法，会需要很多晦涩可笑的隔靴捎痒的操作，但为了最简要地展现机制而不受问题本身的影响，是可以得到非常的重视的。——尽管你只实现了加法的操作。 【81】 geneculture 2011-11-15 16:03 补充： 图10是该虚拟云操作系统第二层b 界面示意图。 由图10 可知，该云操作系统第二层b 界面属于“意”的范畴，具有可间接计算的特点。即：具有“三注”功能或人助机的平台。 【80】 geneculture 2011-11-15 15:59 第8期 因为孪生图灵机在本质上就是一个协同智能计算系统，所以，其标准化的基本数据结构和基本算法与其个性化的具体数据结构类型和具体算法组合之间存在合理分工、优势互补；高度协作、优化互动的融智过程。 换句话说，其人机交互界面除第一和第二两层的标准化界面入口之外，其 第三层及其之后融入的个性化界面入口只能在教学、研究、服务等具体的实践活动中逐步加以完善，分别与“文”和“物”相应的“意”的具体特征，使其必然如此，否则就不足以建构一个标准化与个性化高度融合的完整知识系统。这是知识整体论的要求。但由于自然人主体和计算机代理双方各有其局限，因 此，只有从协同智能计算系统角度提供一个基本的程序来运行该系统，从而，驾驭标准化的数据库及其第一和第二层界面入口，同时，也为个性化的数据库和后续各层界面入口及其与之相应的配套程序提供接口，才能更好地快速实现上述“16 字方略”体现的融智过程。 图1是一种虚拟的孪生图灵机原理图。 图2是与好算法配套的文化基因系统工程蓝图。 图3是可且易计算的（言和语的关系）数据库原理及其调用示例示意图。 图5是基本的数据结构和算法及其组合衍生各类复杂情形之间的关系示意图。 图6是该超级计算机虚拟云操作系统首层界面示意图。 图7是该虚拟云操作系统第二层a 界面示意图。 由图7 可知，该云操作系统第二层a 界面属于“文”的范畴，具有可间接形式化的特点。与其照应的虚拟数据库有图3 所示标准化的字与字组的关系数据库那样的取值特征。 图8是基于双列表的间接形式化方法原理示意图。 由图8 可知，“字、式、图、表、音、像、立体、活体”均可基于双列表而间接形式化。即：本文所述的虚拟孪生图灵机具有（由图3 进一步推广而来）图8 所示的（双列）表格化、（左列）数字化、（右列）字组化“三化”功能。这里的文即广义文本。 图9是孪生图灵机的双路径选择和天平原理图。 图10是该虚拟云操作系统第二层b 界面示意图。 由图10 可知，该云操作系统第二层b 界面属于“意”的范畴，具有可间接计算的特点。 图11是该虚拟云操作系统第二层c 界面示意图。 由图11 可知，云操作系统第二层c 界面属于“物”的范畴，也具有可间接计算的特点。 综上所述，从图6 至图11 笔者向读者展示了一个虚拟的超级计算机云操作系统的虚拟的前台界面和后台数据结构及各种潜在的算法路径。 图12是一个独特的计算机辅助系统的基本程序示意图。 由图12 可知，一种独特的计算机辅助双语教学、研究与服 务系统的基本操作程序，即：... ... 【79】 geneculture 2011-11-15 15:47 第7期（再续） 图12是对称矩阵（方式）与双语处理（策略）及其所遵循的序位法则或原理（已经转化为统一参照系的比对平台或天平转换装置）示意图 图15是（相对于现有的必须不断地进行数据挖掘的污染严重的数据中心而言）洁净数据中心的语言（总量受到控制且易定量分析）和知识（领域得到界定并可定性分析）的计算统计及质性分析（所支持的语言教育和知识管理或人才培养与知识处理的人机协同互助互动的协同智能计算系统的一种具体体现的应用实施例系统工程方案的蓝图）示意图。 图16是整合双重路径的超级宏语言及其类库调改环境及平台（两种路径对接的的高低两种方式）示意图。 ... ... ... ... 图27是在两个参照系之间明确各就各位与各得其所的方法论（相互关系示意图）。 博主回复(2011-11-15 16:05) ： 能不能设计做一个加法看看？看看晓辉的新架构是如何实现协同操作的？ 不要小看这个简单的示例。这是计算示例的“hello world!”. geneculture 2011-11-15 15:33 第7期（续） 图11是软件工程两类形式化途径比较示意图。 由图11 可见，（一）和（二）两条基本的形式化途径，即软件工程形式化方法的双重技术路线。其中，第一路径是学界和业界都非常熟悉的软件工程所谓的直接形式化途径，其特点是：... ... 第二路径是我们发现并明确地提出的软件工程间接形式化途径，其特点是... ...双方彼此遵循的分工协作原则——简称“16 字方针”又叫“协同智能观”。 换句话说，就是要自然人（甲方）与计算机（乙方）遵循“16字方针”或“协同智能观”来构造彼此进行广义双语对话的软 件（样品、产品、商品三位一体）乃至协同实施软件工程（蕴含管理和技术双重服务）。严格地讲，这是和以往的软件和软件工程的固有理念完全不同的另类新理念，即：协同智能。 geneculture 2011-11-15 15:27 第7期 2　软件工程形式化方法第二路径何以优越？ 在上述软件工程学科何以独特这个根本性大问题语境下， 以下将给出软件工程形式化方法第二路径及其重要性的论证。 geneculture 2011-11-15 15:25 第6期 图2是协同智能计算模型及其汉语形式化计算实例示意图。 图3是自然语言文本理解双重技术路线中第二路径的特征示意图。 注：它同时也是双重路径比较示意图。 geneculture 2011-11-15 15:22 第5期 图4是从a 到c 逐渐收敛的孪生图灵机原理示意图。 geneculture 2011-11-15 15:19 提示： 孪生图灵机 有三层示例： a是由并行的两图灵机组成的一个虚拟的孪生图灵机； b是基于“同义并列、对应转换”法则而建构的天平式计量转换装置，其构造原理由实施例c 描述； c是基于可穷举汉语单音节字的文本符号有限集为实施例来说明上述天平式计量转换装置的。 geneculture 2011-11-15 14:57 多数偷懒的读者或用户 都不读FAQ和help 文件 有很好答案的常规疑问 他们却要请他人来解答 故总充当局外人的角色 geneculture 2011-11-15 14:51 这就像大型软件都自带有： Frequently Asked Questions （FAQ）和help 文件一样， 读者或用户只要熟悉FAQ和help 文件所有常规疑问几乎都能得到很好的解答。 geneculture 2011-11-15 14:47 建议或希望嘉文朋友不要偷懒， 至少认真读完以下前三篇文章！ 这样你的很多问题就不是问题， 那时我们再来有针对性的对话， 相信彼此都会更加愉悦和高效。 全文下载： 间接计算模型和间接形式化方法 http://www.ccomsoft.com/kanlist_c.asp?id=272 全文 单击此处 附件下载观看 协同智能计算系统——理论模型及其应用 http://www.ccomsoft.com/kanlist_c.asp?id=306 全文 单击此处 附件下载观看 软件工程学科何以独特——形式化方法的双重路径 http://www.ccomsoft.com/kanlist_c.asp?id=320 全文 单击此处 附件下载观看 虚拟的孪生图灵机——以双语信息处理为例 http://www.ccomsoft.com/kanlist_c.asp?id=319 全文 单击此处 附件下载观看 “云计算”概念的分析研究 http://www.ccomsoft.com/kanlist_c.asp?id=322 博主回复(2011-11-15 16:08) ： 这些链接有权限限制，只能看到摘要。 全文 单击此处 附件下载观看 【70】 geneculture 2011-11-15 10:48 明确回答： “第二路径”（好比是光纤）与“第一路径”（好比是独木桥）之间的关系就是“并联电路”那样的关系， 博主回复(2011-11-15 13:10) ： 存在接口适配的问题。无论是什么脑，既然要两条路并行处理，也就是说，至少在机脑一侧，晓辉还是要借助第一路径来贯彻操作语义。那么，就必须明确第二路径如何与第一路径接口。 原来晓辉提到的是孪生图灵机，我还以为是一种独特的实现操作语义的状态机，不需要传统状态机来实现操作语义，现在的说法，似乎有变化了。 这个孪生图灵机只是一个概念机。 博主回复(2011-11-15 11:41) ： 在何处并联，并联的接口如何定义？这是没有明确的关键的问题。 【69】 geneculture 2011-11-15 10:44 补上这个回应： 可以这样类比。 博主回复(2011-11-7 08:04)：区分“言”和“语”，是不是类似区分“原子”和“分子”？ 原子是化学反应的基本不变元件。 从元素周期表的启示来说，晓辉应该只需要编“言周期表”就可以了，语，应该是“言所进行的化学反应”的结果。 【68】 geneculture 2011-11-15 10:06 同理， 提出“第三脑智”（即“协同智能观”和“协同智能计算系统”） 也就是说， 不能再仅仅从“第一脑智”或“第二脑智”各自的角度来简单地看待原有的一系列问题了。 博主回复(2011-11-15 10:27) ： 至少是 【67】 geneculture 2011-11-15 10:02 因为， 提出“第二路径”不是不要“第一路径”， 而是，等于：进一步提出了“双重路径”。 博主回复(2011-11-15 10:26) ： 如果是这样，晓辉的第二路径需要明确的问题，就不那么多了，但仍然还有艰巨的任务：第二路径和第一路径的接口在什么地方？是什么样的？至少，在机脑的一侧存在接口的问题，在人脑一侧的接口恐怕也不是自然而然的。 博主回复(2011-11-15 10:19) ： 也就是说：第二路径是寄生在第一路径之上的一条局部的并列路径？ 这条路径“宽阔地短路”掉了第一路径上原来狭窄漫长的一部分通道？ 【66】 geneculture 2011-11-15 09:59 或者， 应该给时间让读者重新整理一下思路了。 博主回复(2011-11-15 10:28) ： 或许是读者帮您整理一下思路。 【65】 geneculture 2011-11-15 09:58 说到这里， 我认为够读者消化一阵子了。 【64】 geneculture 2011-11-15 09:55 为什么说： 主要是第二路径的语言教育和知识管理的问题了呢？ 当看完了“软件工程学科何以独特——形式化方法的双重路径”之后， http://www.ccomsoft.com/kanlist_c.asp?id=320 你就会注意到这样一个问题： 必须翻译或解释或编译的单语者和无需翻译的双语者之间的区别。 【63】 geneculture 2011-11-15 09:50 进一步提示： 既然必须启用第二路径的（多数）用户参与进来协作， 那么如何启用第二路径的（多数）用户参与进来协作？ 这就几乎与第一路径的编程无关而是第二路径的语言教育和知识管理的问题了！。 【62】 geneculture 2011-11-15 09:48 请注意： 既然是单靠第一路径的（少数）编程人员所不能胜任的， 那么就必须启用第二路径的（多数）用户参与进来协作。 【61】 geneculture 2011-11-15 09:42 首先表示：我理解并认可这个说法。 晓辉既然理解并认可这个说法，当然也就不会忽视这个重要的问题。 暂时没有直接回应这个说法，只是因为这不是一个简单回应的问题。 现在可以明确地说： 两条路径在各自提出“真正的操作语义端对端的解决方案”时采用了“合”与“分”不同的策略，而晓辉的方案是不仅“合”与“分”两个路径及其不同的策略都要用，而且，还要用两者整合之后它们各自均不具备的“第三脑智”的“双重路径”和“协同策略”。 软件工程学科何以独特——形式化方法的双重路径 http://www.ccomsoft.com/kanlist_c.asp?id=320 http://www.ccomsoft.com/kanlist_c.asp?id=321 博主回复(2011-11-15 09:28)：我在实例讨论的博文中已经点到：第一路径实现了真正的操作语义端对端的解决方案。而晓辉的第二路径，只是实现了符合形式语义的端对端。两条路径的起点和终点是不同的，晓辉忽视了这个重要的问题。 !-- �༭/a--�ٱ� geneculture 2011-11-15 09:33 关于 “贯通到操作语义层次” 我是赞同、理解并支持的。 但是，我想说的是： 这不仅是如何“利用机脑的优势”一个方面的问题， 就是说这是单靠第一路径的编程人员所不能胜任的。 博主回复(2011-11-15 09:38) ： “不仅是”的含义也可以理解为“至少是”。 如果“至少是”的问题没有得到落实，那么，“整体是”就悬浮了。 !-- �༭/a--�ٱ� geneculture 2011-11-15 09:26 理解并赞同： 博主回复(2011-11-15 09:16)：一套完美妥帖的符号体系，只是一个人的美丽的脸。要看她的心（真实的语义处理能力）如何，就必须要用它来处理操作，必须落实到行为操作的层次，才能证明（行为操作是最好的表达），需要跑跑骡子跑跑马。 !-- �༭/a--�ٱ� geneculture 2011-11-15 09:23 站在协同脑智的立场上是这样思考的： 工程融智学，主要解决“间接计算模型和间接形式化方法”的问题， 也就是要找到统一的语言，统一的一套符号，及其相应的操作平台； 应用融智学，主要解决“协同智能计算系统——理论模型及其应用”的一系列问题，也就是如何使用这套语言来处理实际的操作的一系列的问题。 博主回复(2011-11-15 09:28) ： 我在实例讨论的博文中已经点到：第一路径实现了真正的操作语义端对端的解决方案。而晓辉的第二路径，只是实现了符合形式语义的端对端。两条路径的起点和终点是不同的，晓辉忽视了这个重要的问题。 !-- �༭/a--�ٱ� geneculture 2011-11-15 09:17 未来的实践主题： 在协同智能计算系统的超级云支持下去协同来做。 !-- �༭/a--�ٱ� geneculture 2011-11-15 09:12 看过 http://survivor99.com/entropy/2006entropy/3-4/2006-4-8.htm 图11“三化”（语言） 图12“三注”（知识） 之后， 嘉文就应该知道：早就起步并给出了典型示例。 当然，并不是说：所有的事情都不用再去做了。相反，它们不仅还需要很多人去做，而且，可以说，更需要在协同智能计算系统的超级云支持下去协同来做！。 博主回复(2011-11-15 09:23) ： 字本位只是晓辉构造语言文本与数字的形式化映射体系的基础。并没有涉及到我认为“真正到底”的操作语义映射的层次。尤其在机脑这侧，不贯通到操作语义层次，就不可能利用机脑的优势。这就是我说晓辉“海市蜃楼”的原因。 !-- �༭/a--�ٱ� geneculture 2011-11-15 09:09 请见： 字本位与中文信息处理 ——解析“字与字组的关系”探索“汉语形式化”新路 （典型实例：由“一字精解”到“字字精解”） 邹晓辉 http://survivor99.com/entropy/2006entropy/3-4/2006-4-8.htm 图11“三化”（语言） 图12“三注”（知识） !-- �༭/a--�ٱ� geneculture 2011-11-15 09:02 提示或探讨： 不知嘉文是否还记得晓辉“语言（形式）定位系统”（即“三化”方法）和“知识（内容）定位系统”（即“三注”方法）的两幅图解？ 博主回复(2011-11-15 08:48)：我要告诉晓辉的是：我认为晓辉的语言文本的间接形式化也还远未彻底。而语言含义的间接形式化方法还没有起步。发现这一点，就已经是创新了。 博主回复(2011-11-15 09:16) ： 一套完美妥帖的符号体系，只是一个人的美丽的脸。要看她的心（真实的语义处理能力）如何，就必须要用它来处理操作，必须落实到行为操作的层次，才能证明（行为操作是最好的表达），需要跑跑骡子跑跑马。 博主回复(2011-11-15 09:11) ： 是的，我理解，晓辉只是提出了一种表示映射的方法。对这种表示映射如何用来处理逻辑操作，还几乎是空白。这，就是我说，远未彻底的原因。 不管是人脑还是机脑还是协同脑，有了统一的语言，只是一套符号，关键是如何使用这套语言来处理实际的操作。 这就是我一再强调操作语义的重要性的原因。 我们日常说：“知人知面不知心，路遥知马力，日久见人心”，剥离其褒贬之意，其实我们能发现操作语义的原始重要性。 !-- �༭/a--�ٱ� geneculture 2011-11-15 08:59 认同嘉文这个说法或认识。 这就是科学界常说的“提出问题比解决问题更重要”的道理。 博主回复(2011-11-15 08:48)：创新的价值，不是完成多大的工作量，而是发现大量的新的有趣的研究工作可以提供给有兴趣的人跟进。 !-- �༭/a--�ٱ� geneculture 2011-11-15 08:53 研究性大学应当善于发现并扶持这样的人——真正的原始创新者 http://blog.sina.com.cn/s/blog_65197d930100vmyb.html 原创阶段几乎都是纯粹个人的事情，是市场几乎判断不了的事情。 http://blog.sciencenet.cn/home.php?mod=spaceuid=94143do=blogid=508107 !-- �༭/a--�ٱ� geneculture 2011-11-15 08:52 说得很好！ 博主回复(2011-11-15 08:42)：最终回到了同一条战线：已知世界向未知世界发起进攻的前沿战线。这正是人类永恒不变的智力活动的根本任务。这条战线不是清晰的单线条的，不是每一个人，每一个团队都是平齐前进的，不是每一个人，每一个团队都是始终前进的，前前后后，进进退退，这条战线始终在向前推进。 !-- �༭/a--�ٱ� geneculture 2011-11-15 08:47 进一步提示或商讨： 晓辉所解答的问题1和2以及引出问题的那几个帖子，如果联系到一起，那么，就可看出嘉文理解或赋值的第一层意思之后的另几层意思。 !-- �༭/a--�ٱ� geneculture 2011-11-15 08:40 回复： 仅就第一层意思，认同嘉文的下述理解。 再进到二层意思，提示嘉文两点，即： 不仅语言文本可以间接形式化处理并间接计算， 而且语言内容也可间接形式化处理并间接计算。 另外，暂且不管当前学界其他人如何看待或对待HNC，仅就其以字母+数字的组合形式来表达概念的想法和做法而论，也当属第一路径的某种具体的形式化方式。 博主回复(2011-11-15 08:20)：剥离语义和语意的真正价值，就是剥离出了可形式化和不可形式化的语言的逻辑信息。 博主回复(2011-11-15 08:48) ： 我要告诉晓辉的是：我认为晓辉的语言文本的间接形式化也还远未彻底。而语言含义的间接形式化方法还没有起步。发现这一点，就已经是创新了。 创新的价值，不是完成多大的工作量，而是发现大量的新的有趣的研究工作可以提供给有兴趣的人跟进。所以，我认为，晓辉只是在创新，没有在做研究工作。 !-- �༭/a--�ٱ� geneculture 2011-11-15 08:29 探讨或启发： 我认为嘉文对“在下区分的义与意”的理解或赋值是一层意思，有道理，在约定范围内进行文本处理也可行。但是，不排除“在下区分的义与意”还有进一层的意思，也有道理，且在更大的范围内进行文本处理同样也可行。 以上是回复以下嘉文博主回复的第一句，接着再回复第二句，即：不知嘉文是否考虑过这样的情形——事实是会变化的因此它也会造成另一类歧义。 博主回复(2011-11-15 08:08)： 对已知的用“义”，对未知的用“意”。这便是“意”“义”区分的由来。 没有不可理解的事实（纯语义），只有不可理解的说法（含语意和语义）。 博主回复(2011-11-15 09:02) ： 人类是用“义”来沉淀战果，用“意”来谋求新的突破。 所以，我们对“义”要求严格，对“意”可宽容犯错。 博主回复(2011-11-15 08:42) ： 最终回到了同一条战线：已知世界向未知世界发起进攻的前沿战线。这正是人类永恒不变的智力活动的根本任务。这条战线不是清晰的单线条的，不是每一个人，每一个团队都是平齐前进的，不是每一个人，每一个团队都是始终前进的，前前后后，进进退退，这条战线始终在向前推进。 博主回复(2011-11-15 08:36) ： 晓辉，我考虑到了：变化本身就是事实的一部分，变化也有已知变化和未知变化。 !-- �༭/a--�ٱ� geneculture 2011-11-15 05:31 关于合作， 提供一个晓辉的“黄金三角模型”图解： 愿望、能力和机会的关系（人才成长的黄金三角模型） http://kbs.cnki.net/forums/140508/ShowThread.aspx 博主回复(2011-11-15 08:20) ： 现在回想，当时看到的HNC的基本思想，其实已经体现了将“已知和共知事实”部分语义做形式化处理的策略。从而剥离难以形式化处理的“未知和独知”部分的“语意”。剥离语义和语意的真正价值，就是剥离出了可形式化和不可形式化的语言的逻辑信息。 !-- �༭/a--�ٱ� geneculture 2011-11-15 05:29 解读或提示： 从哲学方法论到科学方法体系 其中是由四类集合相互联系的。 从哲学方法论到科学方法体系 http://kbs.cnki.net/forums/140507/ShowThread.aspx !-- �༭/a--�ٱ� geneculture 2011-11-15 05:28 哲学上认为： 世界观和方法论是同一个问题的两个方面。 附（晓辉的一个研究成果图解）： 从哲学方法论到科学方法体系 http://kbs.cnki.net/forums/140507/ShowThread.aspx !-- �༭/a--�ٱ� geneculture 2011-11-15 05:25 一锤定音，认可嘉文的这个判断或结论： 【晓辉转移到了词条含义的形形互证的语义上去了，引起了别人对晓辉不关心“逻辑语义”的误解。】 !-- �༭/a--�ٱ� geneculture 2011-11-15 05:04 中国知网（刊载《软件》5、6、7、8、9五期电子版）： http://www.cnki.net/kcms/detail/12.1151.TP.20110907.1007.001.html http://www.cnki.net/kcms/detail/12.1151.TP.20111004.1537.001.html http://www.cnki.net/kcms/detail/12.1151.TP.20111114.1912.001.html http://www.cnki.net/kcms/detail/12.1151.TP.20111114.1917.002.html http://www.cnki.net/kcms/detail/12.1151.TP.20111114.1922.003.html !-- �༭/a--�ٱ� geneculture 2011-11-15 04:57 全文下载： 间接计算模型和间接形式化方法 http://www.ccomsoft.com/kanlist_c.asp?id=272 协同智能计算系统——理论模型及其应用 http://www.ccomsoft.com/kanlist_c.asp?id=306 软件工程学科何以独特——形式化方法的双重路径 http://www.ccomsoft.com/kanlist_c.asp?id=320 http://www.ccomsoft.com/kanlist_c.asp?id=321 虚拟的孪生图灵机——以双语信息处理为例 http://www.ccomsoft.com/kanlist_c.asp?id=319 “云计算”概念的分析研究 http://www.ccomsoft.com/kanlist_c.asp?id=322 http://www.ccomsoft.com/pic.asp?id=253 !-- �༭/a--�ٱ� geneculture 2011-11-15 04:55 可否这样来看？ 软件工程学是介于工程融智学和应用融智学之间的一门学问。 软件工程学科何以独特——形式化方法的双重路径 !-- �༭/a--�ٱ� geneculture 2011-11-15 04:51 回顾3： 应用融智学的“协同智能计算系统——理论模型及其应用” !-- �༭/a--�ٱ� geneculture 2011-11-15 04:49 回顾2： 工程融智学的“间接计算模型和间接形式化方法” !-- �༭/a--�ٱ� geneculture 2011-11-15 04:47 回顾1： 理论融智学的“三通”： 通论：四大类——物、意、文、理义法道 通则：两定律——第一和第二两信息定律 通式：两公式——广义和狭义的信息方程 !-- �༭/a--�ٱ� geneculture 2011-11-15 04:42 再对好一点： “道”和“德”以及“经”其实分属三个基本类，即： “法”和--------------“文”， “义”和“意”以及“文”， “理”和---“物”及“文”。 博主回复(2011-11-15 08:08) ： 对已知的用“义”，对未知的用“意”。这便是“意”“义”区分的由来。 所以，凡是“义”，必须是“开明尊”的，而“意”，则可以是“密而藏”的。 这样，对“义”就无从误解，对“意”，误解活该。 所以，会有我的这句话：没有不可理解的事实（纯语义），只有不可理解的说法（包含语意和语义）。 !-- �༭/a--�ٱ� geneculture 2011-11-15 04:38 再想一想： “道”和“德”以及“经”三个概念， 难道不正是： “法”和..................“文”， “义”和“意”以及“文”， “理”和.................“物”以及“文”， 可以这样来解读的吗？ 当然， 事前的非显而易见 和 事后的显而易见性 给人的感受不一样。 !-- �༭/a--�ٱ� geneculture 2011-11-15 04:31 试想一想： 柏拉图“意义”概念难以区分“意”和“义” 亚里士多德“物理”概念难以区分“物”和“理”以及其“文法”概念难以区分“文”和“法” 这样的根本性问题， 难道不是非常重要的问题吗？ 这不正是千年不遇的问题吗？ 谁能在这一些列问题的解答上做出其独特的贡献，难道不是难能可贵的事情吗？ !-- �༭/a--�ٱ� geneculture 2011-11-15 04:23 晓辉所解答的问题1和2以及引申问题， 其实可以说是以汉语为母语的人所能超越以英语（以及其它西方语言）为母语的人唯一或者说是少有的具有广阔前景的问题，思考并解决其中任何一个实质性的问题，哪怕是其中一个局部，都是十分难得的千年不遇的机会。其重要性不亚于任何举世闻名的国际难题，其唯一性也不亚于牛顿发现的万有引力定律和沃森发现的基因双螺旋特征以及地位与它们相当的其它科学发现。 !-- �༭/a--�ٱ� geneculture 2011-11-15 04:14 引出的问题： 晓辉认为：近现代乃至当代的英美分析哲学（语言学转向的几个发展）和德法大陆哲学（强调话语的主体间性的多向发展）之所以会对“语义”和“语用”乃至“功能语法”与“认知语法”等等众说纷纭的学问如痴如狂地追捧，乃至癫迷甚至畸形地发展，他们没有甚至不可能区分我前述两个问题（更别说它们的两个解答了）不能不说是其语言瓶颈。 至于说汉语的若干代人的广大学者为什么也没有认识到这两类问题的重要性，其中的原因是复杂的。何况，众所周知，融贯古今中西人文理工（这是解决所有超级复杂问题所必须具备的基本素质）的大学问者从来就极其罕见。晓辉十多年前在（广义和狭义的）融智学问探讨的过程中在理论上主要也只是提出了前述两个问题而已，至于近几年把重点放在了（狭义）融智学问及其实践上从而获得了一系列可喜的实质性进展——若干个显著的可验证且可操作乃至相对容易被协同智能计算系统重复使用的重要突破，也只是开启了（广义）融智学问巨大冰山的一角（充其量也只是几个角）——而其所蕴含的广大未知领域或未开垦的处女地还等待广大师生和众多的学人们共同去探索或开垦呢。 !-- �༭/a--�ٱ� geneculture 2011-11-15 03:46 解答问题2（续）： 又如：晓辉还可在柏拉图“意义”概念难以区分“意”和“义”、亚里士多德“物理”概念难以区分“物”和“理”以及其“文法”概念难以区分“文”和“法”，这样的一些非常重要的根本性问题上做出独特的贡献。 相比之下，李耳（老子、老聃）“道德经”所述的“道”和“德”以及“经”三个概念都是可以明确地区分的。后来的解读者反而有不少人混淆了“道”和“德”两个基本范畴的本质区别，混淆两个字用法的就更是大有人在了。 !-- �༭/a--�ٱ� geneculture 2011-11-15 03:33 解答问题2： 在我看来，由于汉语“意义”可细分为“意”和“义”进且它们三者各自都可有其明确所指的三个不同的类，于是，这就具有了非同寻常的（词语本身的）含义和（晓辉所赋予的）用意。例如：晓辉就可在语言学之父索绪尔区分“语言”和“言语”的基础之上再向前推进一步区分“言”和“语”从而不仅可完成“语言”和“言语”的汉语文本的间接形式化，而且，在解决了汉语理论界百年争论的本位问题——2009年上海国际会议时最终集中到“字本位”与“词本位”之争的同时，也解决了普通语言学、形式语言学、程序语言学、计算语言学长期没有汉语地位的问题——这不仅对说汉语的人不公平而且对因为以往缺乏汉语理论研究突破而几乎都忽略了汉语和汉语理论应当在其中具有其独特地位的那几个基本的重要的普适的语言学分支本身也是一个缺憾。 问题2： 英语meaning翻译成汉语是意义，反之也成立。 但是，英语“meaning”是不能再细分的；而汉语“意义”不仅可以再细分为“意”和“义”而且它们各自都还可以有其明确所指的两个不同的类。 !-- �༭/a--�ٱ� geneculture 2011-11-15 03:16 解答问题1： 在我看来，因为英文单词Semantic说的就是语言的意义或词语的意义， 所以台湾人用“语意”而大陆人用“语义”来翻译都可以粗放地成立。 我强调“意”和“义”的区分也是针对上述这种不区分的粗放的混合， 但是我理解台湾人用“语意”而大陆人用“语义”来翻译的人文背景。 问题1是： 同一个英文单词Semantic台湾人用“语意”而大陆人用“语义”来翻译。这已经也成了惯例。 !-- �༭/a--�ٱ� geneculture 2011-11-15 03:04 因此， 语义和语意（不考虑台湾人的用法）的区分， 是可以用“求同存异，求异存同”来替代的。 !-- �༭/a--�ٱ� geneculture 2011-11-15 03:01 问题2： 英语meaning翻译成汉语是意义，反之也成立。 但是，英语“meaning”是不能再细分的；而汉语“意义”不仅可以再细分为“意”和“义”而且它们各自都还可以有其明确所指的两个不同的类。 !-- �༭/a--�ٱ� geneculture 2011-11-15 02:56 问题是： 同一个英文单词Semantic台湾人用“语意”而大陆人用“语义”来翻译。这已经也成了惯例。

个人分类: 双语信息处理|1510 次阅读|2 个评论

题目：《编程的两种基本思路之比较》

geneculture 2011-10-16 16:18

题目：《编程的两种基本思路之比较》 摘要： 关键词：编程语言；对称矩阵；双语编程 框架： 0.引言 0.1.目的 0.2.背景 0.3.意义 1.基于现有编程语言来进行单语编程 ——如：基于英语的编程语言 2.基于创新对称矩阵来进行双语编程 ——如：基于一系列双列表【即那一对(即左右)矩阵】可采用母语（如汉语）参与编程的做法 3.单语编程与双语编程的区别和联系 ——如：基于左右对称矩阵可采用母语（如汉语）编程的做法与基于现有编程语言来编程的做法之间的区别和联系 4.结论 致谢 参考文献 附录0： ZouXiaohui 12:19:44 我想的是更进一步，即：不仅要把我那两篇的内容加进去作为有力证据，而且，还要把现有的编程思路及其典型例子也加进去作为另一方面的有力证据，通过理论分析和实际比较，让读者自己来判断两种编程基本思路的特点及其对母语是非英语的编程人员以及不懂编程语言的广大普通用户的重要意义。 ZouXiaohui 12:24:11 这样，才可能引发一场计算机编程或软件设计的巨大变革，进而可带来软件产业的重新洗牌——给母语是非英语的编程人员以及不懂编程语言的广大普通用户参与软件市场竞争的公平机会或应有的主动地位。 附录1： ZouXiaohui 12:31:46 从我昨天在交大的报告和交流相当成功的情况来看，大家都逐步开始认识到：软件产业和软件工程正在生着一场基于“第三脑”（本质上是第三智）的革命——它已经由《软件》第5期和第6期刊载的我那两篇论文拉开了序幕，许多师生（它们都是学计算机软件研究生）都已经表现出激动不已和跃跃一试——希望加入进来。 ZouXiaohui 12:32:47 因此，大家对我讲对称矩阵这一块普片都能理解。 附录2： ZouXiaohui 12:48:24 提示：“对称矩阵”引出“双语编程”进而超越（现有的几乎所有的）“编程语言”的单语编程。你现在明白了吗？这就是在软件编程方面来看《软件》第5期和第6期的一个具有革命意义的知识创新——“对称矩阵”+“双语编程”＞＞（现有的几乎所有的）“编程语言”+“单语编程”。 附录3： a 提纲（略） b 创新——“对称矩阵”+“双语编程”＞＞（现有的几乎所有的）“编程语言”+“单语编程” 用例子和比较来论述上述创新的作用和意义 c 引用——《软件》第5期和第6期——打上引号，注明出处；引用其他人写的论著也都要这样。

个人分类: 双语信息处理|1 次阅读|0 个评论

软件工程基本路径的拓展，为何可带来软件产业的重新洗牌？

geneculture 2011-10-16 14:14

说明：以下就是我昨天报告正文部分的三组图解。

个人分类: 《软件》杂志|2025 次阅读|0 个评论

[转载]MATLAB的MEX文件编写和调试

shixuanlv305 2011-10-12 10:04

转自： http://hi.baidu.com/kaien_space/blog/item/fe9d60ec225db72c62d09ffa.html MATLAB的MEX文件编写和调试 1. MEX的编写格式 写MEX程序其实就是写一个DLL程序，所以你可以使用C，C++，Fortran等多种编程语言来写。 编写MEX程序的编辑器可以使用MATLAB的代码编辑器，也可使用自己的C++编辑器，如VS2008等。 用MATLAB的编辑器的好处是，MEX函数会加粗高亮显示，这给程序编写带来便利，可惜无法动态调试。如用VC即可编译也可调试，比较方便。mex的编译结果实际上就是一个带输出函数mexFunction 的dll文件，所以会用VC编写和调试dll，就会用VC编写和调试MEX程序。 a. MEX文件格式 #include "mex.h" void mexFunction( int nlhs, mxArray *plhs ) { } 四个参数分别用来输出和输入数据: nlhs 输出参数个数，plhs 输出参数指针 (nrhs和prhs是输入参数相关的)。 注意: 我们对 输出和输入参数的操作都是通过指针的方式进行的 。(这点很容易理解，因为我们的计算结果是需要传递给MATLAB的，实际上我们传递的不是数据，而是指针。MATLAB可以通过这些指针，访问内存中的数据。) b. 操作输入数据 对输入数据进行操作，需要通过MEX函数mxGetPr 得到数据的指针地址。 mxGetM 和 mxGetN 得到矩阵数据的行和列 (返回整数)。对于实矩阵，我们可以定义 double *M; 来对实矩阵数据操作。如: double *M; int m,n; // 指针指向第一个参数的数据地址 M = mxGetPr(prhs ); m = mxGetM(prhs ); n = mxGetN(prhs ); 需要注意的是， MATLAB矩阵数据的存储顺序是"从上到下，从左到右" 的，这点和Fortran是一样的。也就是说对于MATLAB的m x n的矩阵A。 A(1,1) 就是 *M，A(2,1) 就是 *(M+1) ，以此类推，A(i,j) 就是 *(M + m*(j-1) + (i-1)). 注意: MATLAB的指标从1开始，C的指标从0开始。 c. 操作输出数据 对于输出数据，我们需要首先分配内存空间，有专门的mex函数可以使用，如: plhs = mxCreateDoubleMatrix(m,n, mxREAL); //生成m x n 的实矩阵。 同输入数据一样，要对输出数据操作，我们也需要一个 指向数据的指针变量 ，如 double *A; A = mxGetPr(plhs ); 下面介绍一下如何使用VS2008编写MEX并编译调试。 2. VC中编写MEX 打开VS2008, 新建项目, 选择MFC DLL. a. 配置项目属性 打开项目属性配置页，C++ - 附加包含目录 加入MATLAB安装目录下的 \extern\include 路径。 连接器 - 附加库目录 加入MATLAB的 \extern\lib\win32\microsoft 路径。 连接器 - 输入 - 附加依赖项 输入libmx.lib libeng.lib libmat.lib libmex.lib 这四个lib文件。 b. 编辑输出函数 在项目源文件的. def 中EXPORTS段加入 mexFunction， 如: EXPORTS ; 此处可以是显式导出 mexFunction c. 编写MEX文件 项目文件中新建一个C++文件 如 mexproc.cpp，里面按前面介绍的格式编写代码即可。 d. VC编译MEX 像编译其他程序那样直接编译即可，成功会生成dll文件。如果编译链接时出错，根据错误提示，检查一下lib和h的路径是否正确，有无缺少lib文件，代码是否有语法错误等。 3. VC中调试MEX 要调试MEX程序就要先编译，再调用她。所以我们需要在MATLAB中调用这个函数，并在VC的MEX程序相应位置处下断点即可。调用的函数名就是dll的主文件名，你可以根据自己的需要改名。我们用mymexfun.dll为例，先在VC的 mexFunction 函数代码段开始处F9下断。然后Ctrl+Alt+P附加MATLAB.exe进程。这样就可以运行命令调试程序了。我们可以在MATLAB的命令行里输入命令: = mymexfun(输入变量) (如果命令找不到，检查一下matlab当前路径，和path路径。) 程序一旦被调用，就会被断在我们的断点处。接着你就可以像调试C++程序那样调试MEX程序了。 在MATLAB中编译MEX可以输入: mex 文件名.cpp MATLAB上编译MEX时，你可以选择不同的编译器如lc, gcc等。也可以在编译时附加lib和h文件。关于mex的命令详解请参考MATLAB帮助文档。 kaien

个人分类: 编程|2341 次阅读|0 个评论

图像处理和武功

热度 1 jingpeng 2011-7-2 15:59

各种乱七八糟的编程语言 == 十八般兵器 各种乱七八糟的工具包 == 各种剑法，刀法。。。 各种乱七八糟的算法 == 各门派的内功心法 编程技巧和招式套路，可以速成。 算法理解和内力修炼，需要常年苦修。 牛人一般都是内外兼修的，至少要精通一种语言，算法理解越深越有功力。 只会舞刀弄枪的算不上武林高手，那种修炼到心中有剑的才算真正的高手。 附一份武功秘籍，献给网友：

个人分类: 技术-方法|4743 次阅读|1 个评论

如果编程语言是一条船

热度 1 longxie1983 2011-6-16 16:30

刚刚在google reader上看到的，太给力了。 Turing:小巧，适合初学者，就像 kayak（皮划艇） Java：本身很庞大，能容纳很多东西，就像 货轮 Perl：有四两拨千斤之巧，就像 拖船 Ruby：时尚，性感，总之很潮，就像 摩托艇 PHP：很简陋，有些东拼西凑，就像 木筏 C：指令像外语，但是性能最出色，就像 核潜艇 HTML：根本不是编程语言..... ===================================================================== FORTRAN:专为数字而生的，就像 护卫舰 R, MATLAB, SAS：擅长科学发现，但是需要更大的载体来移动，就像 深海探测器 注：图片来自网络，版权归原作者所有。 原文：http://mendel.soup.io/post/138357929/If-a-programming-language-was-a-boat

个人分类: 杂文|5734 次阅读|2 个评论

文献挖掘工具

热度 2 liumwei 2011-4-12 22:14

如何从数以亿计的文献中，挖掘自己所需要的信息是一件十分复杂的事情。尽管，我们可以通过编程语言的处理就可达到目的，但是互联网中各种不同格式的网页或文本，其字段、关键词、数据、表格、链接抓取等并不是那么容易，特别是pdf文献中那些各种版式的表格、图片、关键语句的获取更是不太容易。这里首推SciMiner。 SciMiner是一个基于网页服务的生物文献挖掘工具。具体可从这个站点了解： http://jdrf.neurology.med.umich.edu/SciMiner/ 。这个工具采用lighttpd驱动，结合数据库Mysql，进行文献的批量挖掘。要下载它，需要使用学术单位邮件地址向进行申请。当前，这个软件包有两种类型，一种可以自行安装配置的核心包，大小145M，而另一种则是预配置好的VmwarePlayer包（即是说，可以利用虚拟机VmwarePlayer直接使用），大小1.1G。核心包的安装需要以下组件或库文件支持（来自SciMiner安装手册）： MySQL database ImageMagick Web-server (如Lighttpd) CGI Perl Perl模组： Boulder::Medline；YAML；Text::NSP；CGI::Debug；CGI::Simple；CGI::Session；CGI::Application； HTML::Template；Data::Dumper；Unicode::String；XML::XPath；Spreadsheet::WriteExcel 这个工具推荐使用Linux系统来安装使用，比如可使用 BioInfoServ 4.0 来安装使用，可省去windows中不必要的麻烦。至于具体的安装配置教程，有空找个时间写个文档出来，供大家参考。 其他的挖掘工具还有很多，下面 这个网页 就值得参考： Tools for Literature-based Discovery Sites that Augment the Standard PubMed Search Service. Sites that are, or Contain Lists of, Search Engines that include Biomedical Topics Sites that are devoted to genes, proteins, and other bioinformatic resources Knowledge Environments (Information Portals, Online Communities) Resources and Tools for Text representation and Visualization General Data Mining and Knowledge Discovery Sites Listservs

个人分类: 科研进行时|8842 次阅读|1 个评论

一个软件的开发笔记（0）

热度 1 ymdushandong 2011-3-2 14:19

从现在开始，着手开发一套能够集成多种遥感模型的软件平台。从概念上讲，规划能够将地表主要的几种典型模型、大气模型集成在一个界面下使用。目标是为了研究生的学习和方便定量化遥感的研究。 本篇博文作为这个分类文件夹的说明。这个文件夹下将逐渐发表开发过程遇到的技术问题和解决情况。作为将来软件平台的技术文档使用。 软件名称：未定， 开发环境：VS2008，编程语言使用C++，显示功能采用MATCOM和IDL的控件。 开发周期：计划：1年.(工作之余的开发，不能强求时间进度) 功能设计： 1. 能够集成目前我们实验室使用的主要的模型：包括： SAIL, PROSPECT, 垄行结构模型， SLEC 模型， TRGM 模型， 微波辐射 / 散射模型？， 6S ， MODTRAN 等等 2. 能够实时图形化显示模拟输入参数和输出结果、分析模拟结果（最大值 / 最小值 / 均值 / 方差，以及这些值的分布位置，以及任意位置的模拟结果查询）；（使用 VC+MatCom 技术） 3. 能够批量模拟（设定关键字，初始值，结束值，步长），进行多组模拟结果的分析（多组数据之间的最大值 / 最小值 / 变化差值 / ）；（使用目前开发的二次语言技术） 4. 能够与图像模拟系统无缝衔接，将输入数据的图像文件准备好后，能够模拟出结果图像；需要在模拟软件中将角度信息等输出，开发一套查找表自动生成和查询模块，灵活的将各种模型嵌入其中。 5. 能够具备基本的图像 - 模型联合研究功能，根据图像 / 传感器参数，自动获取的太阳 - 目标 - 传感器观测几何参数，输入模型，得到模型的结果。

个人分类: 开发手册|4279 次阅读|0 个评论

[转载]2010美国高校计算机系排行榜出炉

NatureXin 2010-4-22 10:28

2010-04-21 00:31 | 次阅读 | 【已有 88 条评论】 发表评论 关键词： 新闻资讯 | 感谢 liujiangCE 的提供 | 收藏这篇资讯 哪些美国高校的计算机系实力最强？4月20日，公认为最具影响力的《U.S. News》美国大学排行榜出炉，为这个问题提供了最新的权威答案。在计算机科学学位项目排行榜中， 卡内基-梅隆大学 （CMU）、 麻省理工学院 （MIT）、 斯坦福大学 和 加州大学伯克利分校 四大名校并列第一，得分不相上下。 专业方向的排名（如下图所示）则显示了这四大名校各自的优势：麻省理工学院在 人工智能 和 计算理论 两个方向折桂，编程语言则落到了第四；加州大学伯克利分校雄踞 计算机系统 方向冠军，但它的人工智能排在第四；以软件工程闻名于世的卡内基-梅隆大学意料之中地占据了 编程语言 头名，计算理论方面却排在了第5（排在第3和第4的是康奈尔和普林斯顿）；斯坦福大学除编程语言外第2外各项都不突出，为什么也能在总榜上排在第一呢，难道是因为在硅谷，学生善于创业好找工作？ 其他位列第5到第10名的学校分别是：康奈尔大学、伊利诺依大学厄巴尼-尚佩恩分校（UIUC）、华盛顿大学、普林斯顿大学、得克萨斯大学奥斯汀分校和佐治亚理工学院。前20名的学校得分情况如下图所示。 IT领域的另一大专业方向 电子电气和通信 排名中， 麻省理工学院 傲视群雄，显示出该校在硬件方面的强大实力， 斯坦福大学 和 加州大学伯克利分校 并列第二。 其他位列前十的学校是： 4 伊利诺依大学厄巴尼-尚佩恩分校（UIUC） 5加州理工学院 6 佐治亚理工学院 7 卡内基-梅隆大学和密歇根大学安亚堡分校（并列） 8 康奈尔大学和得克萨斯大学奥斯汀分校（并列）

个人分类: 未分类|2443 次阅读|0 个评论

关于计算机编程语言的思考——汉语言编程

热度 1 jizw0704 2010-4-19 22:04

计算机的运行主要是由两部分相互作用完成的，即硬件与软件，所说的软件就是在硬件上运行的各种程序。 现行的程序种类丰富，满足着人们各方面不同的需求。这些程序都是由专业程序员编写或者是非专业的程序爱好者利用编程语言编写而成，我们今天就来看看编程语言。 时值当下，编程语言也是多种多样，由一开始的汇编语言，到现在的高级语言，如C，C++，JAVA等等，高级语言越来越受到大家的喜爱，但是要熟练地掌握一门语言，并且灵活自如的运用它来编写各种程序，绝非一朝一夕 首先我们看，这些语言都是英语，各自有各自的语法，这在学习中就是一大障碍，特别是对于英语不是太好的人来说困难更是不言而喻了，那么在次我提出一个想法，能不能利用我们的母语汉语进行编程呢，这样就太方便了。 下面我们看看问题的关键在哪里（可行性讨论）？ 对于一门语言，以C语言为例，用C语言编写的程序为源程序，源程序必须转换，翻译成机器语言，计算机才能识别与执行，我们可以用下面的图来表示： 源程序转换翻译程序机器语言 可以很明显的看出，核心的部分是中间的转换环节，即转换翻译程序，所以只要能正确地把这一部分的程序编写好，那么利用我们的母语编程的可能性就可以做出回答了，显然是可行的。 我相信利用汉语言编程终将引领编程行业，特别是我国的编程行业的长足的发展 吉宗威

个人分类: 观点|6200 次阅读|9 个评论

理想的编程语言

forrestju 2009-8-10 15:14

理想的编程语言鞠文广 以下纯粹是个人观点,不代表任何组织或社团. 现在流行的编程语言如Java和C#,大多是面向对象的,程序的各部分是通过方法调用连在一起,其编程范式是命令编程,即使支持其他范式也包装得很难理解和使用. 面向对象实际上只适合实现抽象数据类型,让它去完成除此之外的任务确实是勉为其难,即便能完成也给人不伦不类的感觉,既不像面向对象编程,也不像它的前任(过程编程).这些语言中的对象与物质世界的物质(或对象)很不一致,它使用方法调用的方式与其他对象进行相互作用,而这与物质之间的(通过通信或媒介)相互作用是截然不同的,因此用面向对象无法很确切地模拟现实世界(面向对象思想的初衷),更不用说准确地为现实世界建立模型. 这几年流行的web服务和SOA虽使程序间交互更方便,但它从本质上说还是使用”面向对象+命令编程+方法调用”的思路,在编程方法论上并没有实质的进步. 用现在流行的语言实现的完成复杂功能的程序逻辑不清晰,原因在于”命令编程+方法调用”的设计机制.这使程序很难模块化,副作用无所不在,因此很难正确实现复杂功能. 现实世界的发展变化是通过事物间的相互作用实现的,而这种相互作用用计算机科学的语言来说就是并发(concurrency).软件的本质是什么?我觉得:软件总是完成某种功能的,归根到底是对现实世界的事物间相互作用进行建模.因此软件的组成部分间自然就是并发的关系,而不是过程调用的关系.用通信进程来对现实世界的事物间相互作用进行建模是比较合理的.所以进程应该作为语言的基础成分,是软件的基本组成部分,而不是只为了提高效率才采用的. 为了使程序能准确地为现实世界建立模型,从而正确性更高,结构更合理,模块化程度更高,因此在几种编程思想或语言的基础上(见references),我提出一种新的编程方法论:面向进程+函数编程+进程间通信+逻辑编程+约束编程+其他合理的范式(命令编程除外)和一门编程语言ProcessLog(全称processlogic). ProcessLog只支持一种并发:通信进程.它就是计算机科学家在上世纪70年代为了克服现在的Java中仍采用的那种并发方式的缺点而提出的.它是经过充分研究得到的一种理想并发方式,看了并发理论(concurrency)和进程代数(Processalgebra),就会明白这种并发方式可解决实际中的各种并发问题,用它足够了. 这里的进程是进程代数的进程,不是过程,也不是Java中的线程.看看jcsp或Hoare的CSP(http://www.usingcsp.com/)就明白了.推荐网址: http://www.cs.kent.ac.uk/projects/ofa/jcsp/, 其中有两个ppt说得很明白: "ProcessOrientedDesignforJava:ConcurrencyforAll", "CommunicatingProcesses,ComponentsandScaleableSystems". ProcessLog的语法概要如下: 1运算符 (1)?输入;c?x从输入端口c或通道c上接收输入值放到变量x中 (2)!输出;c!v把v的值从输出端口或通道c上输出 顺序进行的事件的先后关系 (4)|b:s分支 (5)||进程并行 (6)//附属进程 (7)and,or,not逻辑运算符 (8)算术运算符和关系运算符与Java中相同 2程序的组成成分 (1)Unit程序单元 (2)Process进程 (3)Function函数 (4)Predicate谓词 (5)Channel通道,有两个端口:in输入端口,out输出端口 (6)OutPort输出端口 (7)InPort输入端口 3数据结构 (1)List(函数编程中的List类型,对List的操作函数与函数编程中相同); (2)Tuple元组,同Clean. (3)Set集合 没有数组 4进程的定义 Processp1(OutPortpt1,InPortpt2){ p1 } 进程由事件组成,如pt2?x是输入事件,pt1!compute(x)是输出事件. 5进程间相互作用 (1)进程并行process1(c1.out,c2.in)||process2(c1.in,c2.out) X) 6函数 compute(doublex)= |x<=0:x*x+3 0:compute(x-5)*compute(x-3) 函数只能以事件的方式在进程中使用或在其他函数中使用,不能独立使用. 7谓词 /*建图*/ PredicatecreateGraph(t,graph):- addNode(t,null,({},{}),graph1), getDS(t,graph1.ns,tlist), addList(tlist,t,graph1,graph). /*加节点*/ PredicateaddNode(t,null,(ns,es),(ns1,es):- merge(ns,{t},ns1). PredicateaddNode(t,upper,(ns,es),(ns1,es1)):- merge(ns,{t},ns1), merge(es,{(upper,t)},es1). 8把谓词转换为函数 create(t)=graph wherecreateGraph(t,graph) 谓词不能独立使用也不能在进程中直接使用,先转换为函数后再在进程中使用. 9程序单元:包含进程和数据类型 UnitPMDAO; interface TupleM; ProcessgetReleasedVersion(OutPortpt1,InPortpt2); … implementation M=(Stringid,Stringname,Stringversion,…); ProcessgetReleasedVersion(OutPortpt1,InPortpt2){ … } 指导原则:程序是由通过通道通信的进程组成的.数据处理和算法用函数编程实现,如果函数编程不适用于要处理的问题,就使用逻辑编程或约束编程. ProcessLog语言限制了编程的随意性,要求只能用进程代数+函数编程+逻辑编程的方式编程,不允许用Java或c#的命令方式编程. ProcessLog现在还没有在机器上实现.我用该语言重写了实际项目中的一些复杂代码(原是Java代码),证实用它写的程序确实简单清晰,有类似数学的简洁美."7谓词"就是其中一部分代码. 我的想法是:应先在纸面上规定它的语法与语义,再通过使用它完成一些复杂的项目代码来发现它的不足,再进而改进它,再实践,再改进,直到它基本完善再在机器上实现. 另外,大家不要把语言分为中国人提出的还是外国人提出的,科学无国界. 希望有识之士和我一起共同发展这种编程方法论和这门语言. juwenguang2000@yahoo.com.cn http://www.cnblogs.com/forrestju/ References 1.CSPhttp://www.usingcsp.com/ 2.JCSPhttp://www.cs.kent.ac.uk/projects/ofa/jcsp/ 3.Cleanhttp://clean.cs.ru.nl/ 4.Prolog 5.Delphi 注:转载时请注明作者.

个人分类: 研究|4410 次阅读|1 个评论