quote: Original post by clonemaker

...the "electronic super-programmer" would never actually work on any particular problem; instead it would simply program a copy of itself to do the job for it.

Why do what you can delegate to clones of yourself? Not a bad idea...

OK, bishop_pass, my mistake. I just didn''t get what you meant by what you said and i interpreted it the wrong way.

quote: Give the program a true understanding of the domain it is working in, and let it derive solutions.

Yes, this is an ideal AI program. But how ?


=======================================
Better to reign in hell than serve in heaven.
John Milton, Paradise Lost

quote:
that doesn''t sound that viable, or even efficient. Basically it all comes down to this: we want the computer to do something for us. In order to get it to do that something we need to tell it how.

I wouldn''t be so sure... that''s probably what a lot of people said when some "crackpot" came up with the idea of OOP.

quote:
Ultimately, the more it knows, the easier it is to give additional knowledge, becasue most everything is already there. In theory, it becomes easier to work with and more flexible, as opposed to the standard programing methodology, where the larger it grows, the more difficult it is to work with.

I actually had a similar idea to bishop_pass a while ago. You have some sort of a base program, which is run, and it asks you "What do you want me to do?". You might reply, "Check my e-mails for me".

The program in return will start asking you more questions about its task, e.g. "What is e-mail?", "Who is me?", "How do I check something?" (the base program might have some sort of basic grammatical disector which can distinguish between verbs/nouns/pronouns/etc., and therefore can handle them in different ways)

As you answer more questions, the program finds more and more missing knowledge, and asks you questions about it. It may seem that it would just find more and more missing knowledge, but i''m fairly sure that eventually the whole thing would restabilize and give you a completely working, bug-free program.

I dunno obviously this is very theoretical and I have no idea whether it would work or not, but it''s an idea. I think one of the major hurdles would be explaining to the program what a user is

This sounds too much like a modern "focus" group - lots of people sitting around talking about anything that strikes their fancy, and they end up going in circles or moving backwards.

I think you''ve got some good ideas; ya'' just need some direction. You are trying to come up with a "new" paradigm like OOP? There are other paradigms, too. I think generic programming is in vogue right now (think C++ templates).

Personally, I think attaching oneself to any one paradigm is a bit silly (anyone want to argue that OOP is the best in all situations? heh), though it does make for an interesting discussion. In real life I''d rather just use the language as good as I can in a given situation. Polymorphism? fine. Multiple inheritance? fine. Global functions? fine. Void pointers? fine. Templates? fine. Use the right tool for the right situation. When you start lopping off parts of the language as "useless" or "bad" according to some paradigm you are probably just limiting your abilities.

What I am saying, is why use a paradigm at all?


- null_pointer
Sabre Multimedia

For a program to do the type of knowledge learning some of you are suggesting would take some fairly clever AI. More clever than any AI I''ve seen functioning. More clever than I expect any AI to be in the foreseeable future.

Many intelligent people have been working in the field of AI for decades now, and they still haven''t gotten much past ''Eliza'' style programs (if any AI researchers here bother to flame me, please back it up by posting links to some useful AI that can parse natural language (as many of the posts above suggest should be done) and do anything near the complexity that it would take for the computer to write its own code)...

So you may be asking a bit much at this point in time.

null_pointer there, having seemingly been enlightened since his previous posts.

-Mezz

quote: Original post by gmcbay

For a program to do the type of knowledge learning some of you are suggesting would take some fairly clever AI. More clever than any AI I''ve seen functioning. More clever than I expect any AI to be in the foreseeable future.

Have you heard of predicate calculus and resolution theory? This is a way of describing knowledge. How about planners and belief systems?

quote:
Many intelligent people have been working in the field of AI for decades now, and they still haven''t gotten much past ''Eliza'' style programs

''Eliza'' is terribly superficial and AI has progressed way beyond that. One of the trends I notice among Gamedev posters is how they think problems should be solved. They often look at the results they want and move only one step into the problem space to produce these results. This is what ''Eliza'' did. The results are very superficial and essentially useless.

quote:
...and do anything near the complexity that it would take for the computer to write its own code)...

LISP programs can write their own code quite easily. As for writing C code, here''s a start on how it would be done. Give it knowledge like this:

CodeBody:
InSequenceHas: CodeBodyHeader, OpenCurlyBracket, Statements, ClosingCurlyBracket

CodeBodyHeader:
ValidTypes: ifthen, if, while, dowhile, for

for:
performs: looping
looptestedby: IterationTest

forCodeBodyHeader:
InSequenceHas: forconstruct, OpenParanthesis, Initialization, Comma, IterationFunction, Comma, IterationTest, CloseParanthesis

IterationTest:
IsA: Expression

looping:
UsedIn: RepetitiveTasks
HasComponents: IterationTest

The above is of course just a start on thinking how it would be done, but the point is, the knowledgebase provides conceptual knowledge on what looping is, what an IterationTest is, and so on.

quote:
So you may be asking a bit much at this point in time.

I (we) are not asking for anything. All I''m doing is seeing what people''s opinions are. And I''m seeing how familiar people are with these concepts. I''m also not actually proposing this as a project.

As for links, I don''t have time to sort through my bookmarks, but if you want to see some real AI concepts represantive of this kind of stuff, try searches on any of the following:

cyc
Soar
loom

It seems to me that what you are proposing in your last post is just a higher-level language, which has the same upside and downside of all higher-level languages. Your initial post seems to just to be concerned with an AI able to produce code using that high-level language.

OOP was actually a much larger change than you give it credit for. The ability to have self-contained code objects with the ability to create other code objects to deal with tasks as they arise is closer to what you are really looking for (think of it as a kind of code nanotechnology).

quote: Original post by Anonymous Poster

It seems to me that what you are proposing in your last post is just a higher-level language, which has the same upside and downside of all higher-level languages. Your initial post seems to just to be concerned with an AI able to produce code using that high-level language.

No. Wrong on both counts.

OOP does not have a conceptualization of the inter-relation of all componenets. OOP does have links to different components, but there is a fundamental difference. OOP cannot reason about the links between different components. Adding functionality to an object in OOP needs to be done before you can call on that functionality. Knowledge, on the other hand, uses functionality where available, and recognizes the absence of functionality and attempts to find alternative solutions. Also, OOP does not validate new functionality with the logical framework of the existing knowledge.

I think you''re failing to understand the concept of ''code nanotechnology'' that I was trying to get across. The ideas behind OOP lead naturally to the breaking down of a large problem into smaller and smaller independent chunks until a solution is found. There is no need to reason about the links between different components as they are self-contained and are created to deal with a specific set of circumstances.

I agree with you that functionality must be in place in a code object before it can be used but it is also true that knowledge must be provided before it can be used.

I am not talking about a specific OOP application here by the way - I am merely talking about ideas and the way that OOP principles naturally lead to different ways of thinking, in some ways similar to what you initially proposed.