1 / 19

Advancing Internet Logic Programming with Go!

Introducing Go!, a logic programming language for the Internet era addressing security, complexity, liability, and speed issues in software development. Go! promises high integrity, strong security, disciplined access, and distributed capabilities.

andrew-buckner
Télécharger la présentation

Advancing Internet Logic Programming with Go!

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  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

More Related