Go! - LP for the Internet era

1. Go! - LP for the Internet era Francis G. McCabe Laboratories of America

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

3. Problem #2 Navigational complexity • Software systems meeting without prior intention on the part of the designers • Highly heterogenous, highly complex

4. Problem #3 The software development cycle is too long • By the time a system has been built, in `Internet time' it is already obsolete

5. Problem #4 Programmers and developers are not liable • Accountants, architects, lawyers, journalists are all liable for the quality of their product • So are software developers

6. Our world has changed The Internet changes everything • Even programming languages

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

8. Logic 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

9. Strong static typing High correctness confidence • Gets rid of `stupid' errors Types are usually inferred automatically • Significantly reduced programmer burden

10. Higher 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

11. Discipline 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

12. Distributed 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

13. A 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); }

14. Inside an agent

15. A 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

16. A 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 }

17. Access 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

18. Publish 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

19. Wrap 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