New language for AI?

The following is the list of language requirements I thought an AI would minimally need.

  1. Object Oriented.
  2. All Classes, Methods, Properties, Objects can be created and changed easily by the program itself.
  3. Efficiently run many programs at the same time.
  4. Fully extensible.
  5. Built-in IDE (Interactive Development Environment) that allows programs to be running concurrently with program edit, compile and run.
  6. As simple as possible.
  7. Quick programming turnaround time.
  8. Fast where most of the processing is done.
  9. Simple hierarchy of Classes and of Objects.
  10. Simple Class inheritance.
  11. Simple external file architecture.
  12. Finest possible edit and compile without any linking of object modules.
  13. Scalable to relatively large size.
  14. Built in SQL, indexes, tables, lists, stacks and queues.
  15. Efficient vector handling of all data types.
  16. Internet interface.
  17. Runs on Windows PC machines.
  18. Can run as multiple separate systems on the same computer or in the background

Reasons for the above list of features:

  1. Object Oriented.
  2. All Classes, Methods, Properties, Objects can be created and changed easily by the program itself.
  3. Efficiently run many programs at the same time.
  4. Fully extensible.
  5. Built-in IDE (Interactive Development Environment)
  6. As simple as possible.
  7. Quick programming turnaround time.
  8. Fast where most of the processing is done.
  9. Simple hierarchy of Classes and of Objects.
  10. Simple Class inheritance.
  11. Simple external file architecture.
  12. Finest possible edit and compile without any linking of object modules.
  13. Scalable to relatively large size.
  14. Built in SQL, indexes, tables, lists, stacks and queues.
  15. Efficient vector handling of all data types.
  16. Internet interface.
  17. Runs on Windows PC machines.
  18. Can run as multiple separate systems

Additional Comments:

Compiler advantages/disadvantages

Interpreter advantages/disadvantages

Conclusion:

Addition Points:

I have been asked why I wouldn't just use XYZ version of Lisp. Although I have put forward many reasons why Lisp is not an adequate language for AI and other uses, I will offer the following points specifically about Lisp.

1. Lisp is NOT object oriented. It does have a kind of object add-on but the language is NOT OOPS. It's syntax is ('function name' 'parm1' 'parm2' ...) which is a prefix notation for the standard form of function call which is 'function name'('parm1','parm2' ...). This is NOT OOPS. There is no direct association between the data and methods that change that data as in the object model. In Lisp's defense, it was created in 1956 and object oriented code only became popular on micro computers by about 1990.

2. Lisp has a strange prefix notation.

3. Lisp has much extra detail that isn't needed and adds to it's complexity without providing extra benefit.

The following was taken from a Lisp beginner help session. It shows the 5 different syntax's of the loop function. (Used for looping) 

(1) (loop for I from N1 to N2 do ...)
    Also by and downto variations
(2) (loop for Entry in List do ...)
(3) (loop repeat X do ...)
(4) (loop until Condition do ...)
(5) (loop while Condition do ...)
My language has only 3 kinds of loops. 
1. WHILE 'condition' ... ENDW
2. FOR i=1 to 10 ... NEXT
3. BLOCK 'matrix, varchar, list, table, index etc' ... ENDB

I don't support a post condition (where the test for continuing the loop is at the bottom of the loop) for looping because it is seldom used.
It can be easily simulated with a WHILE _TRUE at the top of the loop and an IF 'condition' BREAK at the bottom.
The BLOCK structure makes defining what is to be done with each member of a matrix, table etc both efficient and easy to read.
Even having this looping mechanism and making it execute a function somewhere else like 'loop for Entry in List do' just doesn't cut it.

My language has only IF ELSE ENDIF, ELSE IF, and the SWITCH command to allow conditional branching.
The computer chips that we all use actually have only GOTO and conditional GOTO commands to accomplish conditional branching.
Any type of program branching can be accomplished with the small set I have implemented.

The following is an excerpt from a beginner's guide to Lisp. 

This is a shorthand for a nested if. The entire form consists of a set of clauses.
Each clause consists of a condition and then any number of actions.
The condition is evaluated, and if true (non-NIL), all the actions are evaluated,
the value of the last one is returned, and the cond exits. Otherwise the process
is repeated for the next clause. Since T is always non-NIL, it is often used as
the condition for an "otherwise" clause.

Example:

(setq X 4)
(cond
  ((oddp X)  (+ X 3))
  ((evenp X) (+ X 2))
  ((< X 9)   999) )      ; This would be true, but is never reached
==> 6

Contrast this with the exact same code in HAL. 

int x, ans
x=4

if x.odd()
	ans=x + 3
else if x.even()
	ans=x + 2
else if x < 9
	ans=999
endif
? ans

Are these two code samples equivalent in terms of understanding what they do? You have never seen HAL before but I would guarantee that all programmers would understand the HAL code. Would everyone understand the brackets, the mixing of functions and variables or even that 'cond' means that a 'condition' is to be evaluated?

Here is another example from Lisp:

Why would there be '*' around a global variable? The whole point of an object oriented language is to match data with the functions that work on it. What does a 'global variable' mean from on OOPS point of view? 

		if a + 5 > 10       // 'a' is obviously a local variable because you weren't told it wasn't
		if cust.a + 5 > 10  // 'a' in this case is a property of the object cust

There is no need to put '*' around the variable name and it is obvious what object the variable 'a' belongs to in the second example. Why put '+' symbols around a variable you want to be a constant? It's your program, just put the value in the variable and don't change it. What could be more simple?

Why make variable names case sensitive when most people's eyes, view a variable like 'foo' and 'Foo' the same? Why set the programmer up for these silly little mistakes when making variables case insensitive costs nothing for the language? Why does a person have to count a bunch of '(' to make sure they are all balanced?

Here is an example of imputing a list of numbers 1, 2, 3, 4 into a list. This is rarely done. Most lists are gathered interactively or from a file and are therefore shown in a program by just a variable name. The ' before the bracketed list is also quite archaic. 

(if (find 3 '(1 2 3 4)) 'Yes 'No) ==> YES
(find 4 '(1 2 3 4 5)) ==> 4

The following is the equivalent in HAL. No part of HAL doesn't look familiar to any programmer. (Excuse the double negative!) 

	class noname inherit list {
		int var
	} mlist              // create the list

	mlist='1,2,3,4,5'    // store 4 numbers into the list
	if mlist.find(3)     // find element of list
		? 'Yes'
	else
		? 'No'
	endif

	? mlist.look(4)      // would display the number 4