理想的编程语言
理想的编程语言 鞠文广
(以下纯粹是个人观点, 不代表任何组织或社团.)
现在流行的编程语言如Java和C#, 大多是面向对象的, 程序的各部分是通过方法调用连在一起, 其编程范式是命令编程, 即使支持其他范式也包装得很难理解和使用.
面向对象实际上只适合实现抽象数据类型, 让它去完成除此之外的任务确实是勉为其难, 即便能完成也给人不伦不类的感觉, 既不像面向对象编程, 也不像它的前任(过程编程). 这些语言中的对象与物质世界的物质(或对象)很不一致, 它使用方法调用的方式与其他对象进行相互作用, 而这与物质之间的(通过通信或媒介)相互作用是截然不同的, 因此用面向对象无法很确切地模拟现实世界, 更不用说准确地为现实世界建立模型.
这几年流行的web服务虽使程序间交互更方便, 但它从本质上说还是使用”面向对象+命令编程+方法调用”的思路, 在编程方法论上并没有实质的进步.
用现在流行的语言实现的完成复杂功能的程序逻辑不清晰, 原因在于”命令编程+方法调用”的设计机制. 这使程序很难模块化, 副作用无所不在, 因此很难正确实现复杂功能.
为了使程序能准确地为现实世界建立模型, 从而正确性更高, 结构更合理, 模块化程度更高, 因此我提出一种新的编程方法论: 面向进程+函数编程+进程间通信+逻辑编程+约束编程+其他合理的范式(命令编程除外).
在几种编程思想或语言的基础上(见references), 我提出了一种编程语言ProcessLog (全称process logic), 语法概要如下:
1 运算符
(1) ? 输入; c ? x 从输入端口c或通道c上接收输入值放到变量x中
(2) ! 输出; c ! v 把v的值从输出端口或通道c上输出
(3) -> 顺序进行的事件的先后关系
(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 进程的定义
Process p1 (OutPort pt1, InPort pt2 ){
pt2?x ->pt1! compute(x) -> p1
}
5 进程间相互作用
(1) 进程并行 process1( c1.out, c2.in)|| process2(c1.in, c2.out)
(2) 附属进程 (getE: getElements || getR: getReleasedVersion) // X.(in?method -> getE ! method ? elems -> getR ! em ? rem-> … ->X)
6 函数
[Function] compute(double x)=
| x<=0: x*x+3
| x>0: compute(x-5)* compute(x-3)
函数只能以事件的方式在进程中使用或在其他函数中使用, 不能独立使用.
7 谓词
/* 建图 */
Predicate createGraph(t, graph):-
addNode(t, null, ({},{}), graph1),
getDS(t, graph1.ns, tlist),
addList(tlist, t, graph1, graph).
/* 加节点 */
Predicate addNode(t, null, (ns, es), (ns1, es):-
merge(ns, {t}, ns1).
Predicate addNode(t, upper, (ns, es), (ns1, es1)):-
merge(ns, {t}, ns1),
merge(es, {(upper, t)}, es1).
8 把谓词转换为函数
create(t)= graph
where createGraph(t, graph)
谓词不能独立使用也不能在进程中直接使用, 要在进程中使用需要先转换为函数.
9 程序单元: 包含进程和数据类型
Unit PmethodDAO;
interface
Tuple Method;
Process getLastVersion(OutPort pt1 , InPort pt2);
…
implementation
Method=(String id, String name, String version);
Process getLastVersion(OutPort pt1 , InPort pt2){
…
}
指导原则: 程序是由通过通道通信的进程组成的. 数据处理和算法用函数编程实现, 如果函数编程不适用于要处理的问题, 就使用逻辑编程或约束编程.
ProcessLog 现在还没有在机器上实现. 我用该语言重写了实际项目中的一些复杂代码(原是Java代码), 证实用它写的程序确实简单清晰, 有类似数学的简洁美. "7 谓词"就是其中一部分代码.
我的想法是: 应先在纸面上规定它的语法与语义, 再通过使用它编写一些应用程序来发现它的不足,再进而改进它, 再实践, 再改进, 直到它基本完善再在机器上实现. 另外, 大家不要把语言分为中国人提出的还是外国人提出的, 科学无国界, 这里不存在狭隘的爱国主义. 我不是那种技术高手, 但我自信我是一个能将理论很好地联系实践的研究者.
希望有识之士和我一起共同发展这种编程方法论和这门语言
References
1. CSP
2. JCSP
3. Clean
4. Prolog
5. Delphi
注: 转载时请注明作者.
[解决办法]
先从精神上支持一下：
实现上应该没问题，难在实现后怎么说服别人使用，已经有haskell, lisp，erlang，...了。
[解决办法]
鼓励楼主。。。
我也在设计编程语言。。。
不过我和你的设计理念不太相同。
楼主在设计一个易于表达机器逻辑的语言。
而我在设计一个易于表达人的逻辑的语言。
有机会我们讨论讨论
[解决办法]
圆是个东西。
圆的半径是1。
圆的直径将是半径*2。
显示圆的直径。（输出2）
圆的半径是3。
显示圆的直径。（输出6）
这是我的语言设计理念能够表达的一段逻辑代码。
（我的设计不是中文的，但是中文可能是一种实现）
[解决办法]
Process Loop
(
DataInPort in(String);
ResultPort out(String)
)
{
in?[msg]
-> (
[解决办法]
not(msg="stop"): out![msg]
->self
)
}
从中可以看出两种语言的并发机制的差别.
[解决办法]
老大你也写两句注释吧。。。
看不懂你在写什么功能。。。
还有对于问题的复杂性：
并不是问题语言复杂描述就复杂。
一门好的语言要好良好的代码隐藏机制（封装）。
比如谷歌的搜索引擎够复杂吧。
但是我们却可以调用，不用自己写那么复杂的程序。
提个建议。
[解决办法]
虽然不懂，支持改变，实践检验
[解决办法]
单纯的面相对像太气人了，根本不能实现它的许诺，高的不伦不类，一个明明白白简简单单的过程硬是挤在类里面，你说这叫什么事啊
[解决办法]
import threading
import time, random
class Counter:
def _ _init_ _(self):
self.lock = threading.Lock()
self.value = 0
def increment(self):
self.lock.acquire() # critical section
self.value = value = self.value + 1
self.lock.release()
return value
counter = Counter()
class Worker(threading.Thread):
def run(self):
for i in range(10):
# pretend we're doing something that takes 10?00 ms
value = counter.increment() # increment global counter
time.sleep(random.randint(10, 100) / 1000.0)
print self.getName(), "-- task", i, "finished", value
#
# try it
for i in range(10):
Worker().start() # start a worker
*********8----------------------------------------
import threading
import Queue
import time, random
WORKERS = 2
class Worker(threading.Thread):
def _ _init_ _(self, queue):
self._ _queue = queue
threading.Thread._ _init_ _(self)
def run(self):
while 1:
item = self._ _queue.get()
if item is None:
break # reached end of queue
# pretend we're doing something that takes 10?00 ms
time.sleep(random.randint(10, 100) / 1000.0)
print "task", item, "finished"
#
# try it
queue = Queue.Queue(0)
for i in range(WORKERS):
Worker(queue).start() # start a worker
for i in range(10):
queue.put(i)
for i in range(WORKERS):
queue.put(None) # add end-of-queue markers
**********--------------------------***********
import threading
import Queue
import time, random
WORKERS = 2
class Worker(threading.Thread):
def _ _init_ _(self, queue):
self._ _queue = queue
threading.Thread._ _init_ _(self)
def run(self):
while 1:
item = self._ _queue.get()
if item is None:
break # reached end of queue
# pretend we're doing something that takes 10?00 ms
time.sleep(random.randint(10, 100) / 1000.0)
print "task", item, "finished"
#
# run with limited queue
queue = Queue.Queue(3)
for i in range(WORKERS):
Worker(queue).start() # start a worker
for item in range(10):
print "push", item
queue.put(item)
for i in range(WORKERS):
queue.put(None) # add end-of-queue markers
**********------------------------***********
import Queue
import bisect
Empty = Queue.Empty
class PriorityQueue(Queue.Queue):
"Thread-safe priority queue"
def _put(self, item):
# insert in order
bisect.insort(self.queue, item)
#
# try it
queue = PriorityQueue(0)
# add items out of order
queue.put((20, "second"))
queue.put((10, "first"))
queue.put((30, "third"))
# print queue contents
try:
while 1:
print queue.get_nowait()
except Empty:
pass
----------------------------------
import Queue
Empty = Queue.Empty
class Stack(Queue.Queue):
"Thread-safe stack"
def _put(self, item):
# insert at the beginning of queue, not at the end
self.queue.insert(0, item)
# method aliases
push = Queue.Queue.put
pop = Queue.Queue.get
pop_nowait = Queue.Queue.get_nowait
#
# try it
stack = Stack(0)
# push items on stack
stack.push("first")
stack.push("second")
stack.push("third")
# print stack contents
try:
while 1:
print stack.pop_nowait()
except Empty:
pass
------------------
import thread
import time, random
def worker():
for i in range(50):
# pretend we're doing something that takes 10?00 ms
time.sleep(random.randint(10, 100) / 1000.0)
print thread.get_ident(), "-- task", i, "finished"
#
# try it out!
for i in range(2):
thread.start_new_thread(worker, ())
time.sleep(1)
print "goodbye!"
-------------------------------
import commands
stat, output = commands.getstatusoutput("ls -lR")
print "status", "=>", stat
print "output", "=>", len(output), "bytes"
*B*status => 0
output => 171046 bytes*b*
-------------------------------
import pipes
t = pipes.Template()
# create a pipeline
# 这里 " - " 代表从标准输入读入内容
t.append("sort", "--")
t.append("uniq", "--")
# filter some text
# 这里空字符串代表标准输出
t.copy("samples/sample.txt", "")
*B*Alan Jones (sensible party)
Kevin Phillips-Bong (slightly silly)
Tarquin Fin-tim-lin-bin-whin-bim-lin-bus-stop-F'tang-F'tang-Olé-Biscuitbarrel*b*
------------------------------------
import popen2, string
fin, fout = popen2.popen2("sort")
fout.write("foo\n")
fout.write("bar\n")
fout.close()
print fin.readline(),
print fin.readline(),
fin.close()
*B*bar
foo*b*
----------------------------------
import popen2
import string
class Chess:
"Interface class for chesstool-compatible programs"
def _ _init_ _(self, engine = "gnuchessc"):
self.fin, self.fout = popen2.popen2(engine)
s = self.fin.readline()
if s != "Chess\n":
raise IOError, "incompatible chess program"
def move(self, move):
self.fout.write(move + "\n")
self.fout.flush()
my = self.fin.readline()
if my == "Illegal move":
raise ValueError, "illegal move"
his = self.fin.readline()
return string.split(his)[2]
def quit(self):
self.fout.write("quit\n")
self.fout.flush()
#
# play a few moves
g = Chess()
print g.move("a2a4")
print g.move("b2b3")
g.quit()
*B*b8c6
e7e5*b*
------------------------
import signal
import time
def handler(signo, frame):
print "got signal", signo
signal.signal(signal.SIGALRM, handler)
# wake me up in two seconds
signal.alarm(2)
now = time.time()
time.sleep(200)
print "slept for", time.time() - now, "seconds"
[解决办法]
该回复于2009-09-28 09:36:44被版主删除
[解决办法]
我的理想的编程语言我找到了！那就是python！
[解决办法]
该回复于2009-10-10 11:19:21被版主删除
[解决办法]
看了楼上这么多位前辈的意见，让小弟受益匪浅；我是主要使用cobol语言的，次要使用java，虽然是古老一点，但是我觉得写程序没必要追求什么时髦语言，推陈出新固然是好，但想想一门语言从开始，发展到完善是不是要经历很长的过程呢，也许我是守旧了一点吧。各位不要介意
[解决办法]
路过 学习一下
[解决办法]
Java 转型 python 中！
望LZ坚持不懈！ 心态————>平常心！------>成功！？
[解决办法]
0o.oO
