第五代PaaS (第五代开发语言平台及服务) 热荐 ★★★ 【字体：小 大】

第五代PaaS (第五代开发语言平台及服务)

作者：佚名文章来源：本站原创点击数： 200 更新时间：2009-8-11

新闻导读：本文从每一代开发语言的角度分析了Paas(平台及服务),给我们在开发语言的方面有了新的视野和角度。

同时关注两家模棱两可的工业标准和晦涩的词语,我们能得到什么呢？那么，对所有你的怀疑者们，答案不是“一个巨大的市场机遇！ ”

认真严肃的汇总，这两个代表未来很有潜力的版本;在未来“没有程序员” 的世界里，即有人没有经验“编写代码” ，也可以快速创建灵活的软件解决方案，实际上增强了实业的流程，并能满足实际业务需求。这是个有趣的设想，其中包括在我们今天可以看到的一个更深入的渗透应用自动化，包括无缝链接外部数据源。

在这里有两个难以置信的价值驱动，对他们的规模和可能产生的影响的理解是非常重要;

1,启动非程序员写程序（ 1000:1）

2,增强商业化，以驱动他们的技术比今天更加深入他们的组织。（提高80 ％生产率，或更多？）

两者合计，这些因素都代表着生产力的革命和自动化正在发生的。 ... 假如它是容易的事,就会有更多的企业云产生。

5GL的概念和Paas似乎是钥匙打开了这一设想。为了解释他们，让我们掌握两个概念并且解剖他们。

什么是第五代语言（ 5GL ）？

想象一下，一把尺子。一端的规则是一个非常具体的标准，仅仅是计算机能识别精确的语言，基本上是“一”和“零” 。另一端的规则是广泛的，有时不完整，往往被误解的语言，人类的语言。机器语言被称为第一代语言， 1GL 。随着计算机的历史演变， “编程语言”，并一步一步的接近人类的语言。

每一次重大突破，在向人类语言靠近，一个新一代的语言被创造出来。这里给你一个非常粗糙集的例子给你理解,它是如何工作的; 2GL –汇编语言。 3GL -结构化的语言;COBOL , Java， C + +。 4GL -解决具体的需要的工具集，思想， RAD工具， OLAP工具，某些Web开发环境。请记住，每一个进步，有计划的语言的通信会大幅度削减开发成本，提高开发人员的效率，并最终提高企业的生产力。

5GL必须进一步向人类语言的道路前进。有些人会认为你不能抽象的一个抽象的事物，因此5GL的是不可能的。还有人认为，真正的5GL的影响是在解释人命令的计算机智能。最后，有些人会说， “如果它发展更快，因此它一定是RAD工具，是 4GL ;然而，问题是， 4GL仍然是涉及代码和程序员。尽管如此，许多人说， 5GL的特点将是某种形式的可视化编程语言，这样的说明可能更加接近真实。

什么可以清晰的解释5GL，它将是能够快速生产的各种先进的软件得大批很有天赋的人才，在此之前只有受过训练的软件开发商可以创造-任何一代语言。

我见过的统计数字说，每一个人用3GL写代码，有几千人用高阶工具工作（我认为Visual Basic中，实际上是高阶工具中引用的统计）。5GL的承诺是使成千上万同时工作，在以前只能一个人做的。在今天可以为商业做什么了？

什么是平台及服务（PASS）？

PASS似乎仅仅是任何形式的“开发平台” ，也就是服务，作为一项服务在互联网上。PASS要求的方案加以利用的能力，PASS 本身不能这么做。实在没有什么好论点来确切定义，但它并没有真正讨论与5GL相关的。我认为PASS是一个5GL的关键因素消除系统管理的各种担忧和其他硬件有关的问题，通常需要一支训练有素的个人共同工作，通过某种代码或命令行界面。PASS，创建者简单的“登陆”和“创建” ... ，然后利用简单的工具，部署，管理和执行其他任务，以维持必要的生产环境，往往只要点击。

华山论剑 — 未来软件开发的语言和工具

2010-3-25 16:42:00 来源：北京世纪长秋科技有限公司

　　前言：自计算机问世以来其应用领域不断扩大，相关产业迅速发展，软件市场的蓬勃发展各种编程语言也孕育而生，到目前为止，编程语言已发展到第四阶段，开发工具更是层出不穷。
　　“攻欲善其事必先利其器”，这是众所周知的道理。一件好的“利器”，就使让我们的工作事半功倍。现在主流的开发语言和开发工具包罗万象，一时间很难把握，那么就让我们从当前社会的主要编程语言，编程工具出发，回顾一下发展过程，历史环境及他们当今所主要涉及的领域等几个方面，从中展望未来的发展趋势。
编程语言及开发工具的发展史
　　第一代编程语言：机器语言。一种很古老的语言。对象很简单就是“0”和“1”。相对应的编程工具是纸带和打孔器。因为计算机多为8位，16位，32位和64位，每次处理一个字节。原理也很简单，1的位就打孔，0的位保留。利用光学原理，遮光为0，透光为1。根据定义位置取得指令和操作数。这种语言比较古老，这里不做表述。
　　第二代编程语言：汇编语言。和机器语言一样，也是面向机器的语言，利用计算机所有硬件特性并能直接控制硬件的语言。优点是可以直接操作计算机硬件，速度快。缺点则是太难理解，所以除非本人所写，且不好维护。不过这里写出的程序是半成品，需要手动汇编成目标文件再连接成中间文件，最后才能生成可执行文件。
　　第三代编程语言：面向过程的编程语言。刚刚问世时叫高级语言，意思为比更接近人的语言。Basic，Fortran ，Cobol ，C，Pascal 等等真正叫做高级语言的原因是它们已有属于自己的编译系统、开发包等，要执行必须通过编译器才行。相比于机器语言和汇编语言，这次是以人类逻辑思维角度出发设计的计算机语言，抽象程度大大提高，模块化思想的引入使得程序更加清晰。可它的缺点是非常难讲述，因为它就是基于面向过程的思想创建，所以自然不具备面向对象的特点。
　　第四代编程语言：面向对象的编程语言。这就是当前主流的开发语言。如C++、Java等。它的几个特点为：（1）封装性，是基于安全考虑。（2）继承性，是基于扩展处理。（3）多态性，更多考虑到灵活性和重用性。第四代语言的开发工具种类丰富。MicroSoft公司的VS系列有多种VC—C++,VB—Basic,VJ—Java,VF—FoxBase，还有基于DotNet平台的C#（最新VS2010还推出F#）等等。如日中天的Java开发工具也很多，下文将根据软件开发未来的发展趋势谈到相关的一部分。
　　以上是四代的编程语言简述，对于第五代编程语言，有很多人提出想法，不过到目前为止还没有任何一个方案能脱颖而出，笑傲群雄。
主流编程语言及工具主要涉及的领域　　到今天，机器语言早已绝迹于江湖，成为古老的传说。汇编语言和C语言基本统治操作系统内核、工业控制、实时系统等领域。近些年在世面上较火的Linux系统下主要用的就是C语言，C++不仅支持面向对象的编程，也支持面向过程的结构程序设计。
　　目前在通信、网络、图形、图像、多媒体平台等领域优势比较明显。在这些领域通常都有很高的性能要求，C++有较高执行效率（汇编和C的执行效率更高但实在难以实现），再加上开发商在开发包方面的重点“照顾”，而使其它语言在算法精度较高的编程方面不能望其项背。
　　曾经有句非常经典的老话：“真正的程序员用VC，聪明的程序员用Delphi。”粗略一看好像这句话有问题，VC是编程工具，而Delphi是编程语言，其实不然。在Delphi1到Delphi7是用Object Pascal语言，到Delphi8以后才改叫Delphi语言，这与平时听到人们讲“我会VC”完全是两回事。VC是编程工具，斧头是伐木工具，如果你因为会伐木就说，“我会斧头”就贻笑大方了，正常的说法应该是“我会用VC”。delphi当初虽是Borland公司研发，但在Windows（上的大多数）编程方面，比VS（包括VC）更容易上手，与WinAPI连接更紧密，（使用者）更容易实现预定的目标，而且更容易做更漂亮的界面。
　　现在大名鼎鼎的QQ最初就是delphi开发，2001年后才逐渐改为VC开发，常用的迅雷也有很多是delphi的版本。简而言之，05年以前凡是VC做到的，delphi同样能做得到（甚至更好），随着Borland公司希望把更多精力投入在新看好的应用程序生命周期管理(ALM)业务上，
Delphi（目前的编程工具属于IDE业务）的传奇之路也走到尽头。95年以后互联网的大跃进，B/S结构越来越受到人们的推宠。APS，PHP，Java……一时间各路英豪各显伸手。
未来编程语言和工具发展趋势
　　未来编程语言和工具的发展趋势大至取决于三个方面，第一，未来计算机网络工作框架及工作模式；第二，当前开发工具对开发语言的支持程度与硬件发展；第三，各种语言的本身的生命力和活力。
　　20年后的计算机网络，我们都知道将会进入到“云计算”时代。“云计算”是大量的网络计算机为我们提供计算机所需的各种服务，而非本地计算机。只需一个浏览器，甚至不需要操作系统，一切工作都通过网络来实现。现在“云计算”已经开始试探性进入我们的生活。
　　做为“云计算”的先锋，可以用到一些在线的工具系统，比如，在线办公、在线电视、在线翻译……，其中很多内容都基于“云计算”模式，尽管还不完善，但也初具规模。不完善是因为在线工作的服务器处理能力不够，网络带宽不够或算法不佳导致的流量分配不合理等，在这里扮演最主要角色的还是服务器的处理能力。现在的高端和大型服务器几乎都被IBM和SUN公司“垄断”。SUN是Java之父，对Java呵护倍至，而IBM更是用一半的力量把其相所有关代码用Java重新编写，并且用另一半的力量在推广Java。不要怀疑Java的开发前景，Java在未来必定是与大型服务器贴合的最紧密、兼容性、有效性最好的语言，Eclipse也将成最火的编程工具。（其实现在Java已经在各种编程语言使用量中排名第一，最近10年中更是9年排名榜首，仅2005年一次失手屈居第二）。
　　Java统治互联网是必然趋势，但Python在未来（桌面程序）扮演重要角色也绝对不能说成是意外。Python具有非常简捷而清晰的语法特点，适合完成各种高层任务，几乎可以在所有的操作系统中运行。更重要的一点是，Python本身的设计理念 “There should be one-- and preferably only one --obvious way to do it”，译成汉语就是对于一个特定的问题，只要有一种明显、最好（完美）的方法来解决就可以。这个设计理念本身很符合未来开发团队的胃口。如果（不用Python来编写）一个软件工程只有概设，没有详设，那最后由工程师写出来的程序很可能是五花八门个性化实足，就算编程人员有很好的开发素养，编码风格统一，也不能保证使用的方法相同，这样程序升级和维护就很受人员限制且效率低下。
　　但如果你使用Python就完全不一样，Python是一种代表简单主义思想的语言。阅读一个良好的Python程序就感觉像是在读英语一样，尽管这个英语的要求非常严格！Python的这种伪代码本质是它最大的优点之一，它使你能够专注于解决问题而不是去搞明白语言本身。Python号称“胶水语言”他能够很轻松的把用其他语言制作的各种模块（尤其是C/C++）轻松地联结在一起。常见的一种应用情形是，使用python快速生成程序的原型（有时甚至是程序的最终界面），然后对其中有特别要求的部分，用更合适的语言改写，比如3D游戏中的图形渲染模块速度要求非常高，就可以用C++重写。Python是最早的（基于互联网的）在线开发语言，Google在推出在线office之后，就把在线Python推给网友，在Google的背景支持下Python肯定会很有前景。　　一种编语言能不能广泛的推广，很大一部分原因取决于它的开发工具好不好用；一种语言开发的软件能不能大量使用，则取决于它的开发包支持的够不够好。
　　C++曾经的状元，在92年VC1.0问世开创可视化编程后，98年VC6.0达到巅峰。除了MicroSoft在02年发布基于WinXP的SDK以后，就基本没有大的动作。VC7，VC8，VC9都只是在编程界面上下的功夫，开发包也没有太多增加。2006年底Vista上市，可支持相关的开发包直到08年VS2008的SP1补丁包中才发布。最近版的VS2010测试版在09年Win7闪亮登场后，终于千呼万唤始出来。这次对VC10在开发工具上确实有不少改进，对C++语法也增加不少支持。VC10增加生成调用树的功能，可以把有层次的调用关系树型表示出来，使程序人员对逻辑结构更加清晰。VC10新加一机多配显示器的功能，并配合程序内部即用即生成的功能，在新增的对函数的模糊查找功能，据说还增强智能感知功能，可以高亮引用。
　　C++的优势在于效率，归根到底还是因为它是编译型语言，产生的代码将有很多工作在寄存器中执行。而Java的是解释型语言，大多代码执行都要入栈，因为寄存器是在CPU中，它的访问速度比内存访问速度快好几个数量级。计算（PC）机的芯片大多都是register computer型（如Intel, AMD），所以Java目前的执行速度没办法与C++相比。
　　之所以现在的嵌入式领域Java比C++流行，就是因为大多数嵌入式芯片都是stack computer型。那你会问，为什么不都采用register computer型的芯片呢？原因不言自明，为了跨平台（跨CPU），现在我们用是双核芯片，但在本机线程都不能跨CPU，何谈“云计算”（云计算本质就是分布式计算）。既然高端大型服务器都被IBM和SUN“垄断”。那CPU的发展又何去何从呢？当C++不再拥有速率优势的时候，是不是有人会说“廉颇老矣”呢。
　　近年来C++的使用量大大下降，要不是与C语言天然的裙带关系，要不是开源的程序在支撑门面，恐怕光靠VC，C++早就江河日下。评论一个事物有没有生命力，就要看它当前的发展程度和未来的发展趋势。Java是由C++中的一流高手设计出来的语言，天然性的摒弃一些C++中不妥不安全不稳定的机制，反射机制又使Java如虎添翼。Java的开源框架资料随处可见，WebLogic,TomCat也都开源可寻，可C++的框架却很少。ACE虽然出名但能拿到源码吗？只能配置。经常会有人问可不可以写个C++版的Hibernate给C++程序员来用，连数据库也不能跨平台。每次提到Hibernate，我不仅联想到风马牛不相及的词汇：哈勃定律。哈勃定律是天文学上的定律，是指所有的星系之间有互相远离的趋势，而且远离的速度越来越大，以此来证明宇宙不断膨胀。Java和C++是不是也像软件行业中的两颗行星呢？
　　活力对于任何开发语言来都是永恒的话题，有没有活力就要看是否与世界上最热门的技术的紧密联系，以及有多少人在关心它。Java已经在3G、数字电视等多个领域都有所建树。Java拥有世界上最多的软件工程师，看看大街小巷各种软件培训的传单，就能看出来人们对这门开发语言有多么关心。
　　综上所述，在未来的20年中汇编和C仍然会在操作系统内核、工业控制、实时系统等领域独树一职，Java在互联网上称王，Python会成为团队开发新的尊者，C++则在目前涉及领域继续发挥余热并与Python成为好伙伴。
篇后语：
　　Java本身是以C++为基础设计，包括Eclipse的好多版本也是用VC来写，如果C++真的不能在未来软件市场王者归来，那会不会是命运的安排？至于Python做为黑客教学的语言，成为未来开发团队标准的开发语言。是不是上天故意开下的一个玩笑？！一切都让我们拭目以待。■

[收藏此页 ] [打印 ] [推荐 ] [评论 ]

微软架构师谈编程语言发展

责任编辑：

晓熊作者：CSDN　 2009-02-20

【IT168 评论】
　　大约2个月前，在Herb Sutter的网站上看到了一个链接，内容是Channel9网站对他和其他三名微软架构师就“编程语言发展”进行的采访，架构师中有Anders Hejlsberg。一看之下，就被这个

计算机语言的发展历程

2007-09-07 16:54:23 来自:

软件平台  语言是人们描述现实世界，表达自己思想观念的工具。而计算机语言是人与计算机交流的工具。一方面人类使用各种计算机语言将所关心的现实世界映射到计算机世界；另一方面，人类又可以通过计算机语言创造现实世界中并不存在的虚拟世界。

计算机的数学理论基础是图灵于1937年提出的图灵机模型，而现代电子计算机的体系结构及实际计算模型则是来自冯.诺依曼1946年提出的“程序放入内存，顺序执行”的思想，因此，现在的计算机通常被称为冯.诺依曼计算机。计算机语言的发展历程也从此正式开始，计算机语言的使用人员也开始被称为程序员。

1.计算机语言的历史回顾

早期程序员们使用机器语言来进行编程运算，直接对以数字表示的机器代码进行操作。后来为了便于阅读，就将机器代码以英文字符串来表示，于是出现了汇编语言。

1956年首先在IBM公司的计算机上实现的由美国的计算机科学家巴科斯设计FORTRAN语言，标志着高级语言的到来。FORTRAN语言以它的简洁、高效性，成为此后几十年科学和工程计算的主流语言，除了FORTRAN以外，还有ALGOL60等科学和工程计算语言。随着计算机应用的深入，产生了使用计算机来进行商业管理的需求，于是COBOL这类商业和行政管理语言出现了，并一直流行至今。

早期的这些计算机语言都是面向计算机专业人员，为了普及计算机语言，使计算机更为大众化，出现了入门级的BASIC语言，至今BASIC语言仍然是绝大多数软件开发人员接触到的第一们计算机语言，同时也最流行的计算机语言。
七十年代初，结构化程序设计的思想孵化出两种结构化程序设计语言，一种是PASCAL语言，另一种是C语言。这两种语言的语法结构基本上是等价的，它们都是通过函数和过程等语言特性来构成结构化程序设计的基础。但是很主要的区别在于PASCAL语言强调的是语言的可读性，因此PASCAL语言至今成为学习算法和数据结构等软件基础知识的教学语言；而C语言强调的是语言的简洁性以及高效性，因此C语言成为之后几十年中主流的软件开发语言，高效性使C语言的地位已相当于一种“高级汇编语言”。

虽然面向对象的思想可以追溯到六十年代，但是面向对象思想被普遍接受还是得益于面向对象语言的功劳。在众多的面向对象语言当中，最为突出的就是C++语言。C++语言是在八十年代初由AT&T贝尔实验室Bjarne Stroustrup在C语言的基础上设计并实现的。C++语言继承了C语言的所有优点，如简洁性和高效性，同时引入了面向对象的思想，如类、封装、继承、多态等。C++语言的这些特性使得C程序员在学习面向对象思想的同时不必放弃已有的知识和经验，原有的软件积累同样可以利用，同时面向对象的设计开发方法使得软件的分析、设计、构造更为完美，因此，C++借助C语言的庞大程序员队伍，成为主流的面向对象语言，并促使面向对象的思想被普遍接受。C++是一种混合型的面向对象语言。象任何人类的自然语言一样，C++语言提供一种表达思想和概念的方法，当问题变得大而复杂时，使用C++语言来解决问题将会比使用其它语言更加容易、更加灵活。在最早的面向对象语言中，除了C++以外，还有一种纯面向对象语言也颇为流行，就是Smalltalk语言，产生并流行于七十末，八十年代初。
计算机语言的发展历史也是人们不断追求更高的模块化、抽象和封装的历史。最初的抽象是以计算机为中心的：首先是将以0和1表示的二进制值抽象为字节、整型、长整型、浮点型等各种预定义的数据类型，然后，为了表达更复杂的数据，出现了以结构表示的自定义数据类型。除了数据的抽象以外，计算机指令也有一个抽象过程：从表达式和语句，到函数和过程。结构化程序设计是以计算机为中心的抽象方式的体现，它所提倡的数据和代码分开的思想和计算机硬件的处理机制是相符的。六十年代末开始出现的软件危机迫使人们去寻找解决办法。解决软件危机的努力主要朝两个方向发展，一是针对软件开发过程的工程管理，提出软件开发的生命周期模型，包括：瀑布式模型、快速原型法、螺旋模型、喷泉模型等等；另外一个解决方法是从对软件开发过程中分析、设计的方法的研究入手，提出了结构化程序设计方法，一时间，“算法+数据结构=程序”几乎成为软件开发的唯一准则。结构化程序设计方法从计算机发展角度来看是自然而然的，但是，今天从抽象的角度来看，这种方法几乎可以说是一个时代错误。软件开发的主要目的就是描述和反映现实世界，现实世界就是由大大小小的对象构成：大到宇宙，小到原子，对象层层包裹；物质世界如此，人类社会的组成也是这样，从作为个体的人，到集体，到整个社会，都可以用对象加以描述。因此，抽象的过程应该是以现实世界的对象为中心的，于是面向对象的抽象方法就走到前台来，为软件开发从分析建模到设计实现提供统一的工具。面向对象技术以及建立在它的基础之上的组件技术为彻底解决软件危机铺平了道路。
大量应用的需求，使得软件开发效率提到日程上来。原有的高级语言，如BASIC、PASCAL等结合可视化的界面编程技术、面向对象思想、数据库技术，产生了所谓的第四代语言，如Visual Basic，Delphi等。Visual Basic的语言基础是BASIC语言，Delphi的语言基础是PASCAL，这两种语言都是软件开发人员所熟知的语言。Visual Basic和Delphi是目前应用软件的主流开发工具。

人工智能一直是人们长期以来的梦想，从图灵开始，半个多世纪以来，计算机科学家们对人工智能进行不懈的探索，这期间，有两种主要的人工智能研究的语言工具，一种是LISP表处理语言，另一种是PROGLOG语言。常有人称二者为第五代语言，但是这两种语言并没有为人工智能的研究带来实质上的进展，因此，不应该称其为第五代语言，我们只能期待着真正的第五代语言的出现。

Internet诞生在六十年代末，此后的二十几年，一直是在缓慢地发展，直到九十年代，HTML语言以及HTML图文浏览器Mosaic的出现，使得Internet在此后十年间得到前所未有的发展。从HTML，到DHTML，再到XML，Web存储格式语言为信息的发布、信息的交流起了极大的作用。这些Web存储格式语言与以往的计算机语言有很大的不同，它们是通过标签来标识内容和数据，从严格意义来说不应该称为计算机语言。

在Web技术的发展过程中，真正可以称为计算机语言，并得到极大的普及的是Java语言。Java是面向对象的网络语言，它的独特的网络特性包括：平台独立性、动态代码下载、为多媒体功能而设计的多线程、为通过Internet快速传送而设计的紧凑的代码格式。Java的工作方式与现有的桌面软件应用程序的工作方式不同。Java程序不需要存储在你的PC机上，而是存储在中央网络服务器。当你通过浏览器访问到一个带有Java小程序的Web页面时，Java小程序就会自动被下载运行。因为Java程序通常都很小的小程序，因此下载运行就会比大程序快得多。此外，版本控制在Java小程序这样的中央存储模式下更为容易。可以从任何一台具有Java虚拟机的机器上访问任何服务器上的Java程序。

九十年代，软件复用的需求和呼声促使组件技术从面向对象技术肥沃的土壤中迅速发芽、成长，并开始结出累累硕果。软件组件定义为自包含的、可编程的、可重用的、与语言无关的代码片段，这样的软件组件可以很容易地插入到应用程序中。软件组件暴露方法和属性，触发事件，并且通过名称或ID号全局表示自己。已经成为流行的标准的组件模型包括COM/DCOM组件模型和CORBA组件模型。组件技术是计算机软件发展的最新结果，也是半个多世纪以来所寻求的有效的软件构造方法。
在计算机语言的发展过程中，先后出现的语言至少有几千种，但是真正能普及应用的计算机语言却是屈指可数的。一种计算机语言要能流行普及，除了要有独有的特色以外，还要切合当时的应用需求。

计算机语言不应该只是思维放大工具，事实上，计算机语言已经成为我们思维的一部分。计算机语言是朝着自然语言的方向发展，它的最终目标应该是成为人类与计算机之间的很自然的交流工具，人可以通过这样的语言将自己所具有的知识，或者自己的思想、情感、愿望等表达给计算机，这样的语言可以称为知识语言或者是智能语言。到了这样的境界，“计算机”的名称应该改成别的什么，因为它与人类智能的界限已经不那么明显了。这就是人工智能，我们人类所梦寐以求的最高境界。
2．从数值运算，符号运算，到组件运算

简单回顾一下运算的历史：最早的运算属于数值运算，它针对阿拉伯数字进行加、减、乘、除等等数学计算；将数值运算抽象出来，数学家们发明了符号运算，这种运算的特征在于它并不指明实际的运算对象，而是以抽象的符号作为运算对象，通过对符号的演绎，数学家们构建了规模巨大的数学公式库，而物理学家们则利用符号运算作为工具来研究物质世界的作用机制。这两种运算的运算对象分别是数字和字符串，以组件的眼光来看，它们属于极特殊的两种组件。

运算是计算机语言的主要功能，早期的计算机语言如FORTRAN就主要是用于科学与工程计算，属于数值运算的范畴。对数学家以及工程人员来说，象公式推导这样的符号运算是极为有用，也是迫切需要的，于是相应的语言工具就出现了，这其中Mathematica语言工具是一种广泛流行的数学工具，它除了具有强大的数值运算功能外，最重要的核心就是它能进行公式推导。在Mathematica内部，有一种模式匹配方法作为其数学运算和公式推导的基础。

既然数值运算和符号运算的运算对象：数字和字符串属于特殊的两种组件类型，那么，除了数值运算与符号运算以外，还应该有组件的运算方式。目前只有KCOM Space这一软件开发平台实现了组件运算。作为一种纯粹的组件平台，KCOM Space的核心优势之一表现在它首先提出并实现了一种全新的运算方式 --- 组件运算。

在纯粹的组件空间里，对象不再只有数字和字符串，而包含有种类和形态丰富多样的组件。这就需要有一种对组件的运算方式，为此，KCOM Space提出并实现了组件运算：组件作为运算对象参与运算，比如定义组件变量、组件常量、组件数组，组件作为值赋给组件变量，组件作为参数用在方法调用中。

组件运算是数值运算和符号运算的发展和扩充，它包含前两种运算方式。组件运算的最明显的特征就是它的直观明了，降低了学习运用的难度，因此组件运算语言也将成为大众化的语言。通过组件运算语言，每一个人都可以将它自己领域的知识表示出来，这样表达出来的组件系统就是知识化的系统，积少成多就可以构成知识组件库。

组件运算的最直接的效果是带来了代码的可视化。面向对象编程语言如C++，在代码中使用组件都是通过一连串的代码来完成的：首先声明一个组件类的实例，然后每一个要设置的属性都需要有一个赋值代码行。相比之下，组件运算使得组件可以直接插入到代码之中，通过组件的属性对话框就可以以可视的方式设置所有待设的属性。这就是代码的可视化。第四代语言的最重要的特征就是界面可视化，也就是能以所见即所得的方式编排用户界面。组件运算引入的代码可视化，使可视化的程度又前进了一步，实现了完全可视化。如果说界面可视化为应用开发效率的提高带来一次飞跃，那么代码可视化再次为应用开发效率的提高带来又一次的飞跃。

组件运算是一个全新的运算领域，但却又是必然的运算发展趋势。结合检索和模式匹配以及控制机制，组件运算将构成未来知识系统的基础。

计算机编程语言简介收藏

一、什么是编程语言？
编程语言是用来表达机器指令的工具吗？是程序员之间交流的桥梁吗？是表达高层设计的载体吗？是算法的符号吗？是表达概念之间关系的途径吗?是实验用的器材吗？是控制计算设备的方法吗？我的结论是，一个多用途（general-purpose）编程语言在上述这些问题的回答都应该为“是”，以满足不同用户的需要。编程语言不能成为——仅仅一些“优雅”特性的集合(a mere collection of “neat” features)。
-Stroustrup [1994], commenting one the apparent lack of “agreement on what a language really is and what its main purpose is supposed to be.”
编程语言是由用来表达计算的符号所组成。它可以被看作是用来定义程序的语法（syntax）及语义(semantic)规则。作为人类与计算机交流的重要桥梁，它的出现与发展，与计算机科学本身息息相关。时至今日，计算机的广泛使用已使上百种编程语言被创造了出来。
编程语言的设计者一直试图在下面两个方面找到平衡点：
² 让语言本身更方便的使用
² 更有效的（efficient）利用计算资源
这里“方便”往往是第一位的，如果语言本身不能够方便地使用，那么效率就无从谈起。
而不同的侧重点及设计哲学，也让众多编程语言之间相去甚远。
二、基本概念
语法（syntax）
语法是编程语言的外壳，程序展现给读者的外在表现就是由语法所决定的。不同的编程语言在语法上会表现出很大的不同。语法给出了一个关于程序合法性的精确定义。通常程序语言对语法的定义结合了正则表达式（regular expressions）和巴克斯-诺尔范式（Backus-Naur Form）[1]。
语义（semantic）
尽管编程语言往往是通过语法给人们留下的第一印象，语义却是编程语言更实质的部分（因此也更加难以描述）。语义定义了一段合法的程序在运行要采用哪种表现（behavior）。
在编程语言中，语义通常用下面几种方式来描述：
² 公理型语义（Axiomatic semantics）
² 指示型语义（Denotational semantics）
² 操作型语义（Operational semantics）
² 自然语言描述（Natural language descriptions）
² 参照工具定义（Reference implementations）
² 测试数据定义（Test suites）
前三种是用数学的方法描述语义。他们的优点是精确、简洁、且能够方便地完成程序正确性的证明。然而，对于庞大的编程语言，用这些数学方法精确定义使语义的描述难以实现。另一方面，自然语言就会使编程语言设计者的描述工作大大减轻。但与此同时，由于自然语言本身的限制，这样的描述往往会表现出不精确的一面。而且、相对于数学方法、自然语言会使语义的描述显得冗长。如：使用自然语言描述的The Java Language Specification, 3rd Ed.有596页那么长。而用操作型语义描述的The Definition of Standard ML, Revised只有114页。
第五种描述方法是参照工具定义，就是说首先将该语言实现出来，并称某个用来实现的工具为“权威的”。而这门编程语言就可以由该程序完整地定义出来。这种描述方法有很多吸引人的特性：精确、无需人去解释，当人们对一段程序该如何表现产生争议的时候只需把这段程序用那个“权威的”工具运行一下就可以判断谁对谁错。然而这种描述方式同样也存在很多缺陷，最大的缺陷是假如这个“权威的”工具本身有Bug，那么这个Bug就不可避免地成为了该语言中的一部分。
第六种描述方法是测试数据定义，这种方法就是，语言的设计者写出大量的例程出来，然后去说明它们应该如何表现（通常将这些例程的输出写出来）。这种描述方法的优点是方便测试语言的实现是否合法（只要把这些例程拿出来运行，看与输出是否匹配即可）。然而用这种方法是无法充分地描述语义的，因此通常这种方法要结合前五种方法一起使用。
实现（implementation）
通常由人写出来的程序是不能够被计算机直接运行的，因此需要一个工具来完成编程语言与机器指令之间的转化。这个转化的过程叫做翻译（translation），实现翻译过程的工具叫做翻译器（translator），人写出来的程序叫做源程序（source program），翻译过后的机器代码叫做目标码（target code）。
实现翻译的有两种方法，编译（compile）和解释（interpret）。对应的翻译器叫做编译器（compiler）和解释器（interpreter）。它们之间的区别可以下面的图示形象地表示出来：

(a)COMPILE
(b)INTERPRET

Application Level…

Language Level…
Source program
Program
Interpreter

Machine Level…
Target code
Machine

Machine

图表 1: 计算机程序有两种实现的方法：（a）编译，自上而下，将源程序转化为可执行的机器代码，然后由机器直接执行。（b）解释，自下而上，制造一个更高级的“机器”（即解释器），来完成对源程序直接执行。
由于可以直接执行源程序，解释型语言相对于编译型语言有着更大的灵活性，它运行在程序的运行过程中改变程序（如临时插入一段代码）。但是由于解释型语言需要每次运行的时候对源程序进行解析，因此在效率上编译型语言要优于解释型语言。
通常我们把源程序本身具备的性质叫做程序的静态（static）属性，而程序在运行中体现出来的性质叫做程序的动态（dynamic）属性。编译型语言更注重程序的静态属性，因为当编译结束之后，机器执行的代码就被确定了下来。而解释型语言可以更多地处理程序的动态属性。
常见的编译型语言有：FORTRAN, C/C++, Pascal, Java[2]等。
常见的解释型语言有：BASIC, Python, MATLAB, 及大部分脚本语言。
数据类型（data types）
计算机内部用二进制状态存储数据，而真实的世界中需要存储的数据多种多样，从人名、银行帐号，再到度量数值。低级的二进制数据在编程语言中被组织起来用以表示高级概念。大部分编程语言用不同的数据类型来表示各种各样的数据。设计和研究类型的专门的理论叫做类型论（type theory）。
根据类型是在程序运行之前进行检查还是在程序运行时进行检查，可分为静态类型语言（static typing）和动态类型语言（dynamic typing）。静态类型语言要求源程序规定每一个数据值都被分配一个确定的类型，在整个程序的运行过程中部发生改变。而动态类型语言的数据类型是在程序运行时才决定的，而且可以随着程序的运行而改变，实际上每个数据的类型是绑定在它的数据值里面，一起在内存中存储。[3]
通常情况下编译型语言都是静态类型语言，解释型语言都是动态类型语言。
另外，跟据编程语言对类型检查的严格程度，可以分为强类型语言（strongly-typed）和弱类型语言（weakly-typed）,强类型语言试图引入严格的类型检查来增强程序安全性，包括静态的类型检查和动态类型检查。排除因程序员犯的类型错误而产生的不安全因素。
例如：ML是静态强类型语言，C是静态弱类型语言，Tcl是动态弱类型语言，Python是动态强类型语言。
三、编程语言的历史
史前时代：λ-演算与图灵机指令
图表 2：阿伦佐·丘奇

编程语言的发展史要追溯的现代电子计算机的发明以前。在众多具有现代编程语言特点的语言中，最具影响力的要数在二十世纪三十年代被创造出来的λ-演算与图灵机指令了。λ-演算是由普林斯顿大学的阿伦佐·丘奇（Alonzo Church）为了研究函数定义，函数性质及递归函数而创造出来的形式化系统（formal system）。而图灵机是英国数学家阿兰·图灵（Alan Turing）假想出的一台有无限存储空间的计算设备，图灵机指令可以看成是汇编语言（assembly language）的前身。这两个类似于现代编程语言概念的提出，起初是想尝试将一阶逻辑命题的判定建立在算法（algorithm）的基础之上，但是随后此二人在各自的系统上分别证明了能够对所有一阶逻辑命题进行判断的算法是不存在的。此后人们便用λ-演算和图灵机去定义可计算性（computability）这个概念。
当电子计算机被发明以后，人们用可读性稍强的汇编语言代替机器代码，但是汇编语言仅仅是机器代码的“直接替换”，因此不可避免的要受限于机器本身，一段汇编代码往往只能在某些特定的机型上运行。
二十世纪五十年代：最初三语言，及Algol
在五十年代初的时候，最初的三个高级语言被创造了出来，他们是
² LISP (the LISt Processor)
² FORTRAN (the FORmula TRANslator)
² COBOL (the COmmon Business Oriented Language)
这三种至今仍有使用，其中Lisp(名字被改为仅首字母大写)对后续编程语言的影响要更大一些。
在1958～1960期间被设计出来的Algol（ALGOrithmic Language）语言，堪称编程语言发展史上的里程碑。很多编程语言的概念在这个语言中被提了出来。Algol的两个主要创新是：
² 首创性地使用巴克斯-诺尔范式描述该语言的语法，几乎所有的后续语言都采用了这种描述语法的方式
² 对程序中出现的标识符（identifier）引入了作用域（scoping）的概念
尽管Algol没有在北美获得广泛的使用（部分由于政治原因，部分由于该语言本身不提供I/O）。然而，Algol却对后续的语言有着深远的影响，包括Simula, Pascal, Scheme和Modula等，而且很多算法教材采用类Algol语言作为伪代码（pseudocode）。
1967～1978：编程范型（programming paradigm）的建立
在这段期间，各种各样的编程语言如雨后春笋般地涌现，而各种编程范型也是在这个时代被建立起来，其中包括：
² Nygaard和Dahl在Simula语言中提出了面向对象程序设计的概念，Simula是一门基于Algol的侧重于做仿真系统的语言。随后精巧的Smalltalk语言进一步地将面向对象的概念深化。
² C，早期的系统编程语言，由Dennis Ritchie与Ken Thompson于1969年～1973年在贝尔实验室开发。
² Prolog，由Colmerauer, Roussel和Kowalski与1972年设计的第一门逻辑编程语言。
² ML，将多类型系统引进Lisp，成为了第一门静态类型的函数化编程语言。
绝大多数的现代编程语言是他们中至少一门的后续。
在六十和七十年代有一场关于选择“结构化编程”还是继续使用“GOTO”的旷日持久的争论。而这场争论与当时编程语言的设计及当时的编程风格息息相关，尽管那场争论在当时十分火热，今天的程序员都承认，除了极少数情况，即便是语言本身支持GOTO语法，使用GOTO都是一个差的编程风格。事实上，后来的编程语言设计者都觉得这场争论不仅无聊，而且令人难以理解。
二十世纪八十年代：巩固、模块化、性能
相比上一个时代，八十年代编程语言开始巩固。C++将面向对象的编程范型与C的系统编程结合了起来。美国政府标准化了Ada, 这是一门用于美国国防部的系统编程语言。在日本等国家，大量的预算被投入研发所谓的“第五代”编程语言（构建于逻辑框架的语言）。在函数化编程方面，ML和Lisp进行了标准化的工作。这个时代并没有创造出新的编程范型出来，相反，人们把原有的范型强化了。
另外，随着程序设计越来越多地应用于大型软件工程，这个时期的编程语言开始引入的“模块化”（modules）。即，把一个大型的程序分成一些小的部分，各个击破，再通过一些办法把这些小的部分组织起来。Modula，Ada和ML都在这个时期开发的自己的模块系统。
在这个时期很多原有的编程范型得到了扩充。例如，Argus和Emerald系统下的编程语言将分布式系统（distributed systems）的概念带入了面向对象程序设计。
编程语言的实现在这个时期也得到了极大的改善。RISC（精简指令集计算机）运动强调硬件的内部构建应该为编译器设计而不是为汇编程序设计。处理器速度的提高大大促进了编译技术的发展。而RISC运动则大大激发了人们发展编译技术的热情。
这种发展一直持续到了九十年代。到了九十年代，一场计算机史上的大革命开始爆发了。
二十世纪九十年代：互联网时代
九十年代中叶互联网的迅速发展将编程语言引向了一个新的时代。由于开放了一个全新的平台，互联网时代为新兴的语言流行提供了机遇。特别是，Java由于被整合进了Netscape Navigator浏览器而普及。而众多脚本语言（scripting languages）则广泛地应用于网络服务器上开发定制的各种应用程序。然而这些语言的出现和发展并没有动摇编程语言设计思路的根基，但是诸如垃圾回收器（garbage collection），强静态类型检查（strong static typing）等新特性逐渐成为主流。
当今编程语言的趋势：
² 增强校验程序安全性和可靠性的机制：如增强类型检查，静态线程（thread）安全性检查。
² 增强编程语言模块化的机制：mixins, delegates, aspects。
² 面向组件的软件开发模式。
² 更强调程序的分布式特性和可移植性。
² 与数据库的整合，包括XML与关系数据库（relational databases）。
² 开放源代码的设计哲学被引入到了新兴的编程语言中去，如：Python，Ruby，Linux操作系统和Squeak。
四、基本编程范型
命令化编程（Imperative Programming）
像自然语言中的祈使句那样，命令化编程是面向操作(action)的。即，将计算看成是一系列操作的执行。它可以将计算抽象成程序的状态（state）及改变程序状态的语句，因此可以看成是图灵机的思想在电子计算机上的实现。
一般认为最早的命令化编程语言是FORTRAN。但是用FORTRAN语言写出来的程序要求精确编写格式（与我们所熟悉的C, Pascal有所不同），而且比较大地依赖大量GOTO的使用。而大量的GOTO直接导致了日趋复杂的程序难以实现。为了解决这场程序设计的危机，以Dijkstra为首的计算机科学家开始倡导结构化编程（structured programming）这个概念。结构化编程通过三种基本类型的语句来代替GOTO的使用：
² 顺序语句：执行A
² 条件语句：IF (expressions) THEN A ELSE B
² 循环语句：WHILE (expressions) DO A
通常结构化编程也支持把一系列语句看成一个“块”（block）,然后把这个“块”内嵌到两个标识符中间（比如说：在ALGOL中的begin和end）。这样，就可以用这三种语句构建出所有用GOTO可以实现的程序控制流（control flow）了。
结构化编程倡导了一种复杂问题的解决方法。当人们面对的问题很复杂以至于无法用简单的办法去解决的时候，可以将复杂的问题分成若干个模块，每一个模块对应一个相对简单的问题。当这些模块完成的时候，这个复杂的问题也就随之解决。而每一个模块又可以分解成更小的模块。这样的过程不断持续，不断地将问题细化。最后如果问题细化到可以用代码实现出来的时候，也就找到了解决这个问题的办法。
结构化编程往往与过程型编程（procedural programming）联系起来。所谓过程型编程，就是把某个实现特定功能的代码段看作一个过程（procedure）[4]，如要实现这个特定的功能，只需要调用这个过程（call）就可以了。这样一段代码可以在不同的地方使用，也就是实现了代码的重用（reuse）。根据不同的需要，一个过程可以有一系列输入及一个输出，通常把输入作为这个过程的参数在调用的时候传递进来，然后过程会根据需要按照计算的结果向外界返回一个值，作为这个过程的输出。
调用过程的一个很重要的应用就是递归（recursion）。在程序设计里面所谓的递归，就是一个过程对自身的直接或是间接的调用。递归在计算机科学中的应用无处不在，大量的算法本质上是将一个问题的求解化归为一个或者若干个更小问题的求解。而应用递归，只需要调用自身，就可以方便地让计算机自动完成这样化归的一个过程。
也有人将过程的调用和递归看成是结构化编程第四种类型的语句。
面向对象编程（Object-Oriented Programming）
面向对象编程打破了长期以来人们对命令化编程就是一系列在计算机上执行的指令的认识。面向对象编程主张：一个程序由一系列的单位元素组成，我们称这个单位元素为对象（object）。而这些对象又是相互作用的，每一个对象可以接受外界的信息，处理自身的数据，以及向外界发送信息。
通常认为最早的面向对象编程语言是Simula，它是将对象（object）、类（class）、继承（inheritance）和动态类型（dynamic typing）这些概念扩充到Algol中去。正如名字所暗示的那样，Simula起初是一门被用作模拟仿真的语言。而正是因为这样的需要使诸如类和对象这些面向对象的元素被添加进来。后来人们发现面向对象编程比结构化编程更适合大型的软件工程，有如下的原因：
² 结构化编程要求在编写程序之前就对要解决的问题有一个全面的认识，才能够对问题不断细化直至细化到代码的阶段。而这些在实际的应用中往往是做不到的，特别是，当程序的编写者想到代码的一个改进的时候，他做出的改动往往会影响到整个程序中去。
² 结构化编程用解空间（solution space）描述问题，而面向对象编程用问题空间（problem space）描述问题。
² 面向对象编程有它一系列的机制更好地实现代码重用（reuse），相比结构化编程，它能够更进一步支持模块化编程。
下面让我们来看看面向对象是什么：
² 类与对象（class & object）
类与对象是面向对象编程最基本的两个概念。类是面向对象编程中最基本的模块。它是被认为是在问题空间中出现的有某些特定的性质和行为的事物的抽象。对象是在程序运行过程中类的实例（instance）,它可以存储自己的数据，但是与类中其他的实例有着相同的表现（即，共享相同的代码）。
² 封装（encapsulation）
封装是构建一个类的最基本途径。通过封装，可以把对象的内部结构和外部接口分离出来。类在经过封装之后，对外呈现出一个接口，外界与这个类中的对象仅能通过接口交互（即，可以理解为向这个类中的对象发送消息）。而类的内部结构仅有该类的设计者所掌握，外界不会因类的内部结构改变而受到影响。封装这个过程让代码有了更好的可扩展性，只要保证对外的接口不变，人们可以不断地对类的内部结构进行改良，而不影响这个类中对象的使用。
² 继承（inheritance）
继承支持在已有的类中创建派生类（derived class）的操作。继承机制提供了一个对已有的类进行外部扩展的机制。子类拥有基类（base class）的一切外部接口，同时可以加入自身独有的外部接口。在问题空间上，继承所表达的是一种“is-a”的关系，比如，狗是哺乳动物，那么可以说“狗”这个类可以继承“哺乳动物”的类。
² 多态（polymorphism）
多态为面向对象编程提供了动态机制。多态的含义是：对于发送过来的相同的一个信息，不同类型的对象会跟据自身的类型，来完成相应类型的操作。也就是说，多态是为不同的类找到一个公共的接口，外界可以通过这个公共接口对这些类的对象发送信息，而不管这些对象具体是属于哪个类的。对象会根据自己属于哪个类完成自己的操作，这一系列的操作都是面向对象的设计方法保证自动完成的，无需人工地进行类型的判断。在面向对象的编程语言中，多态一般是建立在继承的基础之上的。当一个派生类从基类那里继承出来的时候，它可以选择性的重写（override）基类的一些代码。有的时候，我们会把基类当作一个公共的接口，它的不同派生类会对这个公共接口重写不同的代码，因此就完成了多态。[5]
C++将面向对象的元素融入到了系统编程语言C中去，在二十世纪九十年代以前一直是最流行的面向对象编程语言。它提供了多重继承（multiple inheritance）、异常处理（exception handling）、模版（template）、运算符重载（operator overloading）及名字空间（namespaces）等强大的语言特性。它能够广泛流行的另一个原因就是对C几乎完全的向下兼容。
图表 3：Java的吉祥物，Duke

进入九十年代以后，Java成为了使用最为广泛的面向对象编程语言。Java首先简化了C++中一些庞大而繁杂的特性。为了防止C++中经常出现的内存泄露（memory leak）[6]问题，Java引入了自动垃圾回收（automatic garbage collection）机制，将内存的分配与回收自动化，减轻程序员的负担。此外，Java通过自己的一套API及在各个操作系统上的Java虚拟机，真正地实现了平台独立（platform independence）的特性，即实现了“一经写出，到处运行”（write-once/run anywhere）的原则。此外，作为新出现的编程语言，Java对于图形(graphics)，线程（threading）及分布式编程（distributed programming）等有着更好的支持。
函数化编程（Functional Programming）
函数化编程将计算的过程看作是数学函数的求值。它可以排除过程型编程过程的调用对整台机器状态产生的影响。在函数化编程语言看来，一个函数只受它自身的输入影响，对外的影响也只能表现在自身的输出上面。此外，在函数化编程语言中，函数本身也可以作为参数传递到其他函数中去，同样也可以作为返回值传递出来。数学函数由于其本身比较好的性质，为函数化编程带来了一些好处。首先就是更容易证明程序的正确性，另外由于函数化编程消除了副作用（side-effect）[7]，因此它为并行计算（parallel programming）提供了更好的支持。
函数化编程在学术界及爱好者之间有着一定范围的使用。但是在软件工程界，却甚少应用。这主要是基于两个原因。首先是由于种种原因，函数化编程在效率上没有办法和命令化编程（包括面向对象）相比。其次对于已经习惯命令化编程的人来说，函数化编程是很难适应的。
逻辑化编程（Logic Programming）
逻辑化编程是一种由程序的编写者提出规则，然后自动由这些规则进行的推理的编程范型。当数学家和哲学家们发现了逻辑是理论分析的有效工具时，人们便自然地想到了将逻辑风格带入到编程语言中去。当进行逻辑化编程的时候，程序的编写者只需将理论的规则输入到程序中去，然后描述一个问题，这个程序运行时，会对这个问题的真伪进行判断，并建立相应的证明。逻辑推理的过程在逻辑化编程语言中是自动完成的。逻辑化编程与人工智能领域的关系密不可分。
逻辑化编程在一些领域有着它的应用：
² 专家系统，程序从一个巨大的模型中产生一个建议或答案。
² 自动化证明定理，程序产生一写新定理来扩充现有的理论。
五、结论
程序设计的广泛用途，促成了编程语言的千变万化。从数值计算、系统编程，到大型的应用软件，再到网络编程。编程语言的每一次进步与发展，都与人们的需求密不可分。而人们的需要，又无时无刻不伴随着计算机科学自身的发展。因此，要想学习一门编程语言，仅仅了解其语法、语义，或是仅仅能用其写出一些程序，是远远不够的。若能够深入剖析某门编程语言的特性，就会发现这些特性所影射出来的设计哲学，进而看到当今或是某时代的计算机科学发展状况。希望本文能够起到一个抛砖引玉的作用，激发起同学们探索、学习的热情，提升自己的视野，让自己站在一个更高的位置上去，从而为计算机科学做出自己的贡献

--------------------------------------------------------------------------------

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/ganghust/archive/2007/03/17/1532203.aspx

编程语言简史（翻译）

本文发表在《CSDN开发高手》第九期上。请勿随意转载。

我们已经远离用电线和穿孔卡编程的时代。也许仍未尽如人意。以下内容都是编程历史上的创新。

ca. 1946

Konrad Zuse，一位德国工程师，他躲藏在巴伐利亚附近的阿尔卑斯山上时，独立开发了Plankalkul。他把该项成果应用在其它的事物中，比如国际象棋。

1949

Short Code ,第一种真正在电子计算设备上使用的计算机语言，尽管他是一个纯手工编译的的语言。

1951

Grace Hopper，为Remington Rand工作，是在第一个著名的编译器——A-o上开始设计工作。当Rand在1957年发布这个语言时，它被称为MATH-MATIC。

1952

Alick E. Glennie ,他利用自己在曼彻斯特大学的课余时间，发明了一个名为AUTOCODE的编程系统，一个未能成型的编译器。

1957

FORTRAN——数学公式转换系统（FORmula TRANslating，FORTRAN名字的由来）——出现。开发队伍的领导者是John Backus，并且他还为ALGOL的开发和巴柯斯范式（BNF）做出了贡献。

1958

FORTRAN II出现，它能够处理子程序和连接汇编语言。由M.I.T的John McCarthy在LISP-LISt Processing上开始设计工作。

原始的ALGOL规范出现。该规范并未描述数据的输入输出方式；这些问题都留给独立的实现者。

1959

LISP1.5出现。COBOL在数据系统和语言大会（Conference on Data System and Languages）上被创建了。

1960

ALGOL 60 ,第一种结构化语言出现。它是结构化语言家族树中的根节点，并最终产生Pascal这样的语言。ALGOL成为六十年代中期至末期欧洲最为流行的语言。

六十年代早期，Kenneth Iverson开始语言方面的工作，最终产生了APL-A编程语言。它使用专门的字符集，为了正确地使用，你还需要兼容APL的I/O设备。

1962

APL被写入Iverson的《A Programming Language》一书中。

FORTRAN IV出现。

SNOBOL这个以“首字母拼词命名”的产品，在工作的初期就取得了绝对的成功，SNOBOL——面向字符串符号（StriNg Oriented symBOlic Language）语言。它衍生了其他一些以首字母拼词命名的产品： FASBOL，一个SNOBOL编译器（1971年），还有SPITBOL——Speedy ImplemenTation of snoBOL——同样在1971年。

1963

ALGOL 60进行修正。

PL/1的工作开始。

1964

APL\360被实现。

在达特茅斯大学，John G.Kemeny和Thomas E.Kurtz教授发明了BASIC。最初的实现是一个编译器。第一个BASIC程序在1964年五月一日下午四点运行。

PL/1发布。

1965

SNOBOL3出现。

1966

FORTRAN 66出现。

LISP 2出现。

在Bolt，Beranek和Newman开始了LOGO的工作。小组的头是Wally Fuerzeig，而且还包括Seymour Papert。LOGO中最著名的便是“龟作图”。

1967

SNOBOL4，功能获得极大加强的SNOBOL，出现了。

1968

ALGOL 68，相对于ALGOL 60它是个怪物。一些规范委员会的成员——包括C.A.R.Hoare和Niklaus Wirth——却赞同该计划。事实证明ALGOL 68是难以实现的。

ALTRAN，一个FORTRAN的变种出现。

COBOL被ANSI正式定义规范。

Niklaus Wirth开始Pascal方面的工作。

1969

500人参加在纽约Armonk的IBM总部召开的APL会议。APL的分发需求如此之大，该活动此后被人们称为“The March on Armonk”。

1970

70年代早期，Charles Moore在他的语言Forth中写下了第一个有意义的程序。

Prolog方面的工作大约在此时开始了。

同样是在70年代早期的某一天，Xerox PARC由Alan Kay领导，开始了Smalltalk的设计工作。早期版本包括Smalltalk-72，Smalltalk-74和Smalltalk-76。

Pascal在CDC 6000-series电脑上的一个实现出现了。

Icon,SNOBOL4的一个后代产品问世。

1972

Konrad Zuse写的关于Plankalkul（见1946年）手稿终于出版了。

Dennis Ritchie设计了C。但是最终的参考手册却是在1974年发布的。

Prolog的第一个实现——Alain Colmerauer和Phillip Roussel的功劳。

1974

另一个COBOL的ANSI规范出现。

1975

Tiny BASIC，由Bob Albrecht和Dennis Allison设计（由Dick Whipple和John Arnold实现），运行在2KB内存的微型计算机上。一台4KB的机器是较为合适的，它将有2KB的内存应用于这个程序上。

Bill Gates和Paul Allen编写的一个BASIC版本以抽取每份拷贝版税的形式销售给MITS（Micro Instrumentation and Telemetry Systems）。MITS生产Altair，这是一种8080结构的微型计算机。

Scheme，一个LISP的“方言”，由G.L. Steele和G.J. Sussman设计。

Pascal用户手册和报告出版，Jensen和Wirth编写。许多人至今都认为它是Pascal方面权威的参考书籍。

B.W. Kerninghan描述了RATFOR——RATional FORTRAN。它是预处理程序，并且允许在FORTRAN中使用类C的控制结构。RATFOR被应用到了Kernighan和Plauger的“Software Tools”中，它出现在1976年。

1976

Design System Language出现，它被认为是PostScript的先驱。

1977

MUMPS的ANSI标准出现——麻省总医院多用途程序设计系统（Massachusetts General Hospital Utility Multi-Programming System）。MUMPS最初被用来处理医疗记录，它只能识别字符串类型。随后被重新命名为M。

设计竞赛将导致Ada的产生。由Jean Ichbiah带领的Honeywell Bull队伍，即将赢得比赛。

Kim Harris和其他人建立了FIG，一个FORTH兴趣小组。他们开发了FIG-FORTH，售价大约为20美元。

70年代晚期的某天，Kenneth Bowles设计出了UCSD Pascal，它使得Pascal可以用在PDP-11和基于Z80 的电脑上。

Niklaus Wirth开始设计Modula，它Modula-2的先行者，Pascal的继承者。

1978

AWK——一个文本处理语言，以它设计者Aho、Weinberger和Kernighan的名字命名。

FORTRAN 77的ANSI标准出现。

1980

Smalltalk-80出现。

Modula-2出现。

Franz LISP出现。

Bjarne Stroustrup开发了一个语言集——被总称为“C With Classes”——它成为C++的滋生土壤。

1981

Effort开始成为一个LISP的“公共方言”，常被人称作Common LISP。

日本开始第五代电脑系统工程。主要语言是Prolog。

1982

ISO Pascal出现。

PostScript出现。

1983

Smalltalk-80公布：它由Goldberg等人完成。

Ada出现。他的名字来自Lovelace女伯爵Augusta Ada Byron，她是英国诗人拜伦的女儿。因其在巴贝奇分析机上设计了解伯努利方程的一个程序，而被誉为第一位女程序员。在1983年，国防部指导的全新“任务评定”应用程序是使用该语言编写的。

1983年的后期和1984年早期，微软和Digital Research共同发布第一个微型计算机的C编译器。

七月，第一个C++实现露面。该名称是由Rick Mascitti取的。

11月，Borland的Turbo Pascal的“冲击”犹如一场核风暴，这得益于《BYTE》杂志的广告。

1984

APL2的参考手册面世。APL2是APL的扩展，它允许嵌套数组。

1985

Forth控制着潜水器定位泰坦尼克的残骸。

Vanilla SNOBOL4之微机版发布。

Methods，PC上的面向行(line-oriented)的Smalltalk出现。

1986

Smalltalk/V露面——第一个广泛应用于微机的Smalltalk版本。

Apple公司为Mac机器发布Object Pascal。

Borland发布Turbo Prolog。

Charles Duff发布Actor，一个开发微软Windows应用程序的面向对象语言。

Eiffel，另外一个面向对象语言出现。

C++露面。

1987

Turbo Pascal 4.0发布。

1988

CLOS规范——公共LISP对象系统（Common LISP Object System）——发表。

Niklaus Wirth完成Oberon，这是他继Modula-2的后续行动。

1989

ANSI C规范公布。

C++2.0形成了一个参考手册的初稿。2.0版本增加了诸如多继承和成员指针等特性。

1990

C++2.1，B.Stroustrup等作者的《Annotated C++ Reference Manual》一书出版。这个版本增加了模板和异常处理特性。

FORTRAN 90包含了众多新元素比如case语句和派生类型。

Kenneth Iverson和Roger Hui在APL 90会议上提出了J语言。

1991

Visual Basic在COMDEX春展会上获得《BYTE》杂志颁发的最佳表现奖。

1992

Dylan——以Dylan Thomas命名——由Apple公司发布的一个类似Scheme的面向对象语言。

1993

ANSI发布X3J4.1技术报告——面向对象的COBOL提议初稿。真正的标准预计在1997年完成。

1994

微软将Visual Basic for Application整合到Excel中。

1995

二月，ISO接受Ada语言1995修订版。它被称为Ada95，其中包括OOP特性和支持实时系统。

1996

第一个ANSI C++标准预发布。

编程语言时序表

这是一个以编程语言时间顺序排序的清单。

包含的时间年代

1 pre 1950
2 1950
3 1960
4 1970
5 1980
6 1990
7 2000

1950之前

查看格式为：

父语言（“*”表示没有此项）年代子语言 ——开发者或公司

* 1840~第一个程序 -- Lovelace

* 1945 Plankalkül -- Zuse

1950

* 1952 A-0 -- Hopper

1954 Mark I Autocode -- Brooker

A-0 1954 ARITH-MATIC -- Hopper

A-0 1955 MATH-MATIC -- Hopper

A-0 1955 FLOW-MATIC -- Hopper

A-0 1955 FORTRAN -- Backus

1956 Information Processing Language -- Newell, Shaw, Simon

FLOW-MATIC 1957 COMTRAN -- Bemer

FORTRAN 1958 FORTRAN II -- Backus

FORTRAN 1958 Algol 58

* 1959 LISP McCarthy

1960

FLOW-MATIC COMTRAN 1960 COBOL The Codasyl Committee

ALGOL 1960 Algol 60

ALGOL 1960 JOSS

FORTRAN II 1962 FORTRAN IV

* 1962 APL -- Iverson

ALGOL60 1962 Simula

FORTRAN II 1962 SNOBOL -- Griswold, et al.

ALGOL60 1963 CPL -- Barron, Strachey, et al.

SNOBOL 1962 SNOBOL3 -- Griswold, et al.

CPL LISP 1964 COWSEL Burstall, Popplestone

ALGOL60 1964 /A> IBM team

FORTRAN II, JOSS 1964 BASIC -- Kemeny and Kurtz

FORTRAN II 1966 FORTRAN IV

LISP 1966 ISWIM Landin

ALGOL60 1966 CORAL66 Real Time version of Algol 60

CPL 1967 BCPL -- Richards

Fortran LISP 1967 MUMPS -- Massachusetts General Hospital

Simula 1967 Simula67

SNOBOL3 1967 SNOBOL4 -- Griswold, et al.

Algol60 1968 ALGOL 68 -- Wijngaarten, et al.

COWSEL 1968 POP-1 -- Burstall, Popplestone

1968 Forth -- Moore (first paper, 1970)

Lisp 1968 Logo -- Papert

1970

POP-1 1970 POP-2

ALGOL60 1971 Pascal -- Wirth, Jensen

Simula67 1972 Smalltalk Environment -- Smalltalk--Digitalk

B BCPL 1972 C -- Ritchie

* 1973 PROLOG -- Colmeraurer

BASIC 1973 COMAL

LISP 1975 Scheme -- Sussman, Steele

BASIC 1975 Altair BASIC -- Gates, Allen

C FORTRAN 1976 RATFOR -- Kernighan

MUMPS 1977 X11.1 ANSI Standard MUMPS

FORTRAN IV 1978 FORTRAN77

( * 1978 VISICALC -- Bricklin, Frankston)

C SNOBOL 1979 Awk -- Aho, Kernighan

( * 1979 VULCAN DBASE-II -- Ratliff )

Algol68 1979 Green -- Ichbiah et al., US Dept of Defense

1980

C Simula67 1980 C with Classes -- Stroustrup

Simula67 1980 Smalltalk-80 -- Digitalk

Green 1983 Ada -- US Dept of Defense

C with Classes 1983 C++ -- Stroustrup

Pascal 1983 Turbo Pascal -- Hejlsberg

* 1984 Standard ML ML = Meta-Language

1977MUMPS 1985 1984 MUMPS

( dBase 1984 CLIPPER -- Nantucket )

( dBase 1985 PARADOX -- Borland )

Simula67 1986 Eiffel -- Meyer

( * 1987 HyperCard -- Apple )

( * 1987 SQL-1 )

Awk 1987 Perl -- Wall

MATLAB 1988 Octave

dBase-III 1988 dBaseIV

Awk Lisp 1988 Tcl -- Ousterhout

Turbo-Pascal 1989 Turbo-Pascal+OOP -- Borland

C 1989 Standard C -- ANSI X3.159-1989 (adopted by ISO in 1990)

Pascal Modula-II 1989 OBERON -- Wirth

1990

1990 Haskell

1984MUMPS 1990 1990 MUMPS

1991 Python -- van Rossum

1991 Q

( SQL-1 1992 SQL-2 )

Turbo-Pascal OOP 1992 Borland Pascal

1993 Brainfuck -- Mueller

Perl Smalltalk 1993 Ruby

1993 Lua

Ada 83 1995 Ada 95 -- ISO

Borland Pascal 1995 Delphi(1) -- Borland

C++ Internet OOP 1995 Java -- Sun Microsystems

1990MUMPS 1995 1995 MUMPS

Standard ML,84 1997 SML’97

PHP 3 1997 PHP

C++ 1998 C++98 -- ANS/ISO Standard C++

2000 Joy -- von Thun

C C++ COM Java 2000 C# -- Microsoft

DELPHI(5) 2001 KYLIX -- Borland

Whitespace 2003 Whitespace -- Brady and Morris

一些数据不完全的资料：

* 197? sh (Bourne Shell) -- Bourne

sh 19?? ksh (Korn Shell) -- Korn

ksh 199? zsh (Z Shell)

HyperCard 199? AppleScript -- Apple

* 1990 Self -- Sun Microsystems Inc

Self Java 199? LiveScript -- Brendan Eich, Netscape (Self inspired, made for Java interactions)

LiveScript 1995 JavaScript -- Netscape

JavaScript 1997 ECMAScript -- ECMA

What makes a 5GL?

Impossible, but ...

By Philip Howard, Bloor Research • Get more from this author

Posted in Developer, 17th January 2007 17:25 GMT

Free whitepaper – Trying to keep smartphones off your network?

Comment From time to time vendors in the application development space have claimed 5GL (5th generation language) capabilities. If you think about this for a moment you will realise that this can't be true. The idea of GLs is that each is an abstraction of the former, so we had machine code (on which I cut my teeth as a developer); assembler; third generation languages such as COBOL, Java, C++ and so forth; and finally 4GLs (now sometimes referred to as ABLs-advanced business languages-as 4GL seems to be out of fashion).
You can't get a further level of abstraction than a 4GL so there can't be such a thing as a 5GL, just as you can't abstract further than meta-meta-metadata (which is what high-end repositories provide).

So, if you can't get beyond a 4GL, what can you do to a 4GL to make it a quantum step forward compared to current 4GLs, even if it isn't actually a 5GL?

One possible answer is that you could build a data federation engine into the development environment. This would allow you to create applications that accessed diverse, heterogeneous data sources. Now, data federation has typically been thought of as being used for EII (enterprise information integration) and the premise has been that it is about queries. But a database look-up is, from a theoretical perspective, just a query, even if it is going to be used for a transactional application, so supporting data federation within a development environment sense. Indeed, it is easy to see how such an approach could be used for building MDM (master data management) applications, for example.
So, is there anybody actually doing this? Well, as you might guess, yes. A small UK company called Abbro Interactive has a tool called Abbro (now in version 3-it has been in use for some seven years), which does exactly this. You can go to the company's website and take a look at the facilities provided but the key to note is that this is a 4GL with extras that, in the case of federation, includes the ability to reverse engineer existing databases to create database views that can then be merged or joined, and caching capabilities so that reading the same data from these sources does not mean repeated database access.
The product is based on its own scripting language which is interpreted dynamically at run-time by the Abbro engine. It has to work this way because it is intended that applications will be event-driven, so event exits may occur at any time. Note that this facilitates the deployment of workflow as well as alerts, notifications and so on. It includes the ability to scan documents and populate forms therefrom, support for bar codes (and, at least in theory, RFID tags) and GPS messages so that you can determine the locations of things.
As I said: a 4GL with extras.
However, you can't buy Abbro as a product: at present all you can do is to have the company build an application for you using Abbro (based on a proof of concept, if required), which should be significantly faster (in terms of delivery) and cost less money than would normally be the case. Once you've got the application you can customise it but the underlying logic will be developed by Abbro Interactive for you. The company does have one package built on Abbro, for export documentation, but its potential uses are much broader than this. The company is considering how it might make use of channel partnerships but however good the product is, we cannot expect to see widespread deployment while Abbro itself remains the only company doing core development work.

Fifth-generation programming language

From Wikipedia, the free encyclopedia

Jump to:

navigation, search

This article or section has been nominated to be checked for its neutrality, as an editor who has substantially contributed to the current version may have a conflict of interest. Discussion of this nomination can be found on the talk page. (May 2009)

A fifth-generation programming language (abbreviated 5GL) is a programming language based around solving problems using constraints given to the program, rather than using an algorithm written by a programmer. Most constraint-based and logic programming languages and some declarative languages are fifth-generation languages.
While fourth-generation programming languages are designed to build specific programs, fifth-generation languages are designed to make the computer solve a given problem without the programmer. This way, the programmer only needs to worry about what problems need to be solved and what conditions need to be met, without worrying about how to implement a routine or algorithm to solve them. Fifth-generation languages are used mainly in artificial intelligence research. Prolog, OPS5, and Mercury are examples of fifth-generation languages.^{[citation
needed]}
These types of languages were also built upon Lisp, many originating on the Lisp machine, such as ICAD. Then, there are many frame languages, such as KL-ONE.^{[citation
needed]}
In the 1990s, fifth-generation languages were considered to be the wave of the future, and some predicted that they would replace all other languages for system development, with the exception of low-level languages.^{[citation
needed]} Most notably, from 1982 to 1993 Japan^[1]^[2] put much research and money into their fifth generation computer systems project, hoping to design a massive computer network of machines using these tools.
However, as larger programs were built, the flaws of the approach became more apparent. It turns out that, starting from a set of constraints defining a particular problem, deriving an efficient algorithm to solve it is a very difficult problem in itself. This crucial step cannot yet be automated and still requires the insight of a human programmer.
Today, fifth-generation languages are back as a possible level of computer language. A number^[who?] of software vendors currently claim that their software meets the visual "programming" requirements of the 5GL concept.

[edit] Common misconception

From time to time vendors in the application development space have claimed 5GL (5th generation language) capabilities.^[3] Most of the time they actually sell 4GLs with a higher levels of automation and knowledge base. Since the 5GL awareness has dropped because the hype of the 80's quickly faded away and that the projects were eventually all dropped; this has opened doors to the vendors to re-use the term in marketing their new tools, without causing much controversy among the current generations of programmers. Their tools actually consist of 4GLs packed with RAD wizards, CASE tools and other graphical coding assistance that facilitates code generation.

[edit] See also

[hide] v • d • e Programming language generations

Generations Overview - 1GL / 2GL / 3GL / 4GL / 5GL

[edit] References

^ Richard Grigonis. "FIFTH-GENERATION COMPUTERS". http://www.atariarchives.org/deli/fifth_generation.php. Retrieved 2008-03-05.
^ ALP. "Association for Logic Programming (ALP)". http://www.cs.kuleuven.ac.be/~dtai/projects/ALP/. Retrieved 2008-03-05.
^ What makes a 5GL?

Retrieved from "http://en.wikipedia.org/wiki/Fifth-generation_programming_language"

Categories: Programming language classification

Hidden categories: NPOV disputes from May 2009 | All articles with unsourced statements | Articles with unsourced statements from September 2010 | Articles with unsourced statements from July 2009 | All articles with specifically marked weasel-worded phrases | Articles with specifically marked weasel-worded phrases from August 2010

Xiangqun Financial Intelligent Algorithmic Cloud Developer向群财经智能算法交易与云计算开发http://sfebbf.xqact.com

2012年4月23日星期一