Go! - LP for the Internet eraGo! - LP for the Internet era

Francis G. McCabe

Laboratories of America

Problem #1Problem #1

On average 3~10 security updates to Linux per week Most caused by buffer overflow holes C is too weak for secure programming

Problem #2Problem #2

Navigational complexity Software systems meeting without prior

intention on the part of the designers Highly heterogenous, highly complex

Problem #3Problem #3

The software development cycle is too long By the time a system has been built, in

`Internet time' it is already obsolete

Problem #4Problem #4

Programmers and developers are not liable Accountants, architects, lawyers, journalists

are all liable for the quality of their product So are software developers

Our world has changedOur world has changed

The Internet changes everything Even programming languages

Go!Go!

Go! is an Internet ready logic programming language Aimed at high integrity, high security Aimed at agent based systems

Logic programming basedLogic programming based

Strong semantic basis What you see is what you mean c.f. `Proof by compiler' semantics of C, Java

Rule based Closer to human intention

Simple elements Functions, relations and theta expressions

Strong static typingStrong static typing

High correctness confidence Gets rid of `stupid' errors

Types are usually inferred automatically Significantly reduced programmer burden

Higher OrderHigher Order

Programs are 1st class entities More disciplined than meta-logical Much clearer interfaces between programs Supports `fancy' features such as code

repositories, code mobility easily

Not higher-order logic Functionally equivalent to FOL Avoids some nasty pitfalls of HOL

DisciplineDiscipline

Disciplined access to resources File system `sand box' Code verification built in

Disciplined assignment Assignable variables are lexically scoped Only updateable by programs defined within

the same scope Not visible otherwise

Distributed and multi-taskingDistributed and multi-tasking

Based on notions of active process

Processes only communicate via visible mechanisms

Uniform messaging infrastructure Communication is the same across the

network as within a single activation

A simple program about ancestorsA simple program about ancestors

{ p('a','b'); p('a','c'); p('b','d'); p('e','d'); p('f','e');

an(x,y) :- p(x,y); an(x,y) :- p(x,z), an(z,y);}

Inside an agentInside an agent

A fragment of an agent controllerA fragment of an agent controller

{ Active := []; mgr() :- proposal(T)<<H, profitable(T,H), Active := [spawn task(proposal(T),H),..Active], mgr();

profitable(T,H) :- ...

}.mgr

A code repositoryA code repository

{ DB := []; inter ::= face(t) | prov(t,handle);

cr() :- repeat { face(C)<<client ->> { prov(C,server) in DB, face(C) >> client } | prov(F,S) ->> DB := [prov(F,S),..DB] } forever}

Access the codeAccess the code

{ inter ::= face(t) | prov(t,handle);

Pan = Px::{ face(Px:(p:(symbol,symbol){},an:...))) >> CR, face(Px)<<CR};

goGo() :- Pan.an('me','you');}.goGo

Publish codePublish code

{ inter ::= face(t) | prov(t,handle);

proxy = { p('a','b'); ... p('f','e');

an(x,y) :- p(x,y); an(x,y) :- p(x,z), an(z,y); };

publishPan() :- prov(proxy,self()) >> CR; }.pubishPan

Wrap upWrap up

Go! is still in design stages Most of the elements are in place Compiler being constructed

Go! is targetted at the right problems!

LP is the right framework for building agents themselves

Go! prototype system will be available under an Open Source Licence