An Overview of the Ciao Multiparadigm Language and Program Development Environment and Its Design Philosophy

We describe some of the novel aspects and motivations behind the design and implementation of the Ciao multiparadigm programming system. An important aspect of Ciao is that it provides the programmer with a large number of useful features from different programming paradigms and styles, and that the use of each of these features can be turned on and off at will for each program module. Thus, a given module may be using e.g. higher order functions and constraints, while another module may be using objects, predicates, and concurrency. Furthermore, the language is designed to be extensible in a simple and modular way. Another important aspect of Ciao is its programming environment, which provides a powerful preprocessor (with an associated assertion language) capable of statically finding non-trivial bugs, verifying that programs comply with specifications, and performing many types of program optimizations. Such optimizations produce code that is highly competitive with other dynamic languages or, when the highest levels of optimization are used, even that of static languages, all while retaining the interactive development environment of a dynamic language. The environment also includes a powerful auto-documenter. The paper provides an informal overview of the language and program development environment. It aims at illustrating the design philosophy rather than at being exhaustive, which would be impossible in the format of a paper, pointing instead to the existing literature on the system.

[1]  Manuel V. Hermenegildo,et al.  Abstraction-Carrying Code , 2005, LPAR.

[2]  Manuel V. Hermenegildo,et al.  Automatic Compile-Time Parallelization of Logic Programs for Restricted, Goal Level, Independent and Parallelism , 1999, J. Log. Program..

[3]  Christian Holzbaur,et al.  Metastructures versus Attributed Variables in the Context of Extensible Unification , 1992, PLILP.

[4]  Pierre Deransart,et al.  Programming Languages Implementation and Logic Programming , 1989, Lecture Notes in Computer Science.

[5]  Hassan Aït-Kaci An introduction to LIFE: Programming with Logic, Inheritance, Functions, and Equations , 1993, ILPS.

[6]  Saumya K. Debray,et al.  Lower Bound Cost Estimation for Logic Programs , 1997, ILPS.

[7]  Saumya K. Debray,et al.  Global Flow Analysis as a Practical Compilation Tool , 1992, J. Log. Program..

[8]  Elvira Albert,et al.  An Incremental Approach to Abstraction-Carrying Code , 2006, LPAR.

[9]  Manuel V. Hermenegildo,et al.  Efficient Term Size Computation for Granularity Control , 1995, ICLP.

[10]  Manuel V. Hermenegildo,et al.  Complete and Efficient Methods for Supporting Side-effects in Independent/Restricted AND-Parallelism , 1989, ICLP.

[11]  Manuel V. Hermenegildo,et al.  Some methodological issues in the design of CIAO, a generic, parallel concurrent constraint system , 1994 .

[12]  Pieter H. Hartel,et al.  Programming Languages: Implementations, Logics, and Programs , 1996, Lecture Notes in Computer Science.

[13]  Krzysztof R. Apt,et al.  Logic Programming , 1990, Handbook of Theoretical Computer Science, Volume B: Formal Models and Sematics.

[14]  Manuel V. Hermenegildo,et al.  Automatic Exploitation of Non-Determinate Independent And-Parallelism in the Basic Andorra Model , 1993, LOPSTR.

[15]  Manuel V. Hermenegildo,et al.  Abstract Interpretation with Specialized Definitions , 2006, SAS.

[16]  Manuel V. Hermenegildo,et al.  Combining Static Analysis and Profiling for Estimating Execution Times , 2006, PADL.

[17]  Ehud Shapiro,et al.  Third International Conference on Logic Programming , 1986 .

[18]  Manuel V. Hermenegildo,et al.  Implementing Distributed Concurrent Constraint Execution in the CIAO System , 1996, APPIA-GULP-PRODE.

[19]  WadlerPhilip,et al.  Report on the programming language Haskell , 1992 .

[20]  Patrick Cousot,et al.  Abstract interpretation: a unified lattice model for static analysis of programs by construction or approximation of fixpoints , 1977, POPL.

[21]  Manuel V. Hermenegildo,et al.  Integrated program debugging, verification, and optimization using abstract interpretation (and the Ciao system preprocessor) , 2005, Sci. Comput. Program..

[22]  Manuel V. Hermenegildo,et al.  Abstract specialization and its applications , 2003, PPoPP 2003.

[23]  Manuel V. Hermenegildo,et al.  A Simple Approach to Distributed Objects in Prolog , 2002 .

[24]  Manuel V. Hermenegildo,et al.  The Ciao Modular, Standalone Compiler and Its Generic Program Processing Library , 1999, Parallelism and Implementation Technology for Logic Programming@ICLP.

[25]  Manuel V. Hermenegildo,et al.  A Documentation Generator for (C)LP Systems , 2000, Computational Logic.

[26]  Manuel V. Hermenegildo,et al.  High-level languages for small devices: a case study , 2006, CASES '06.

[27]  Manuel V. Hermenegildo,et al.  An Abstract Machine for Restricted AND-Parallel Execution of Logic Programs , 1986, ICLP.

[28]  Saumya K. Debray,et al.  Cost analysis of logic programs , 1993, TOPL.

[29]  Peter J. Stuckey,et al.  Optimization of Logic Programs with Dynamic Scheduling , 1997, ICLP.

[30]  The Ciao Multiparadigm Language and Program Development Environment , .

[31]  Manuel V. Hermenegildo,et al.  An Automatic Translation Scheme from Prolog to the Andorra Kernel Language , 1992, FGCS.

[32]  Saumya K. Debray,et al.  Non-Failure Analysis for Logic Programs , 1997, ICLP.

[33]  Manuel V. Hermenegildo,et al.  Some Techniques for Automated, Resource-Aware Distributed and Mobile Computing in a Multi-paradigm Programming System , 2004, Euro-Par.

[34]  Manuel V. Hermenegildo,et al.  A Generator of Efficient Abstract Machine Implementations and Its Application to Emulator Minimization , 2005, ICLP.

[35]  John Hughes,et al.  Report on the Programming Language Haskell 98 , 1999 .

[36]  Manuel V. Hermenegildo,et al.  Implementation of multiple specialization in logic programs , 1995, PEPM '95.

[37]  Victor W. Marek,et al.  The Logic Programming Paradigm: A 25-Year Perspective , 2011 .

[38]  Jan Maluszy¿ski,et al.  Lower Bound Cost Estimation for Logic Programs , 1997 .

[39]  Manuel V. Hermenegildo,et al.  Determinacy Analysis for Logic Programs Using Mode and Type Information , 2004, LOPSTR.

[40]  George C. Necula,et al.  CCured: type-safe retrofitting of legacy software , 2005, TOPL.

[41]  T. Schrijvers Analyses, Optimizations and Extensions of Constraint Handling Rules (Analyses, optimalisaties en uitbreidingen van constraint handling rules) , 2005 .

[42]  Manuel V. Hermenegildo Why Ciao? An overview of the ciao system's design philosophy , 2006 .

[43]  Manuel V. Hermenegildo,et al.  The &-Prolog system: Exploiting independent and-parallelism , 1991, New Generation Computing.

[44]  Saumya K. Debray,et al.  On the Practicality of Global Flow Analysis of Logic Programs , 1988, ICLP/SLP.

[45]  Francesca Rossi,et al.  Strict and Nonstrict Independent And-Parallelism in Logic Programs: Correctness, Efficiency, and Compile-Time Conditions , 1995, J. Log. Program..

[46]  Manuel V. Hermenegildo,et al.  Improved Compilation of Prolog to C Using Moded Types and Determinism Information , 2004, PADL.

[47]  Kim Marriott,et al.  Independence in CLP languages , 2000, TOPL.

[48]  Saumya K. Debray,et al.  Towards Granularity Based Control of Parallelism in Logic Programs , 1994, PASCO.

[49]  Manuel V. Hermenegildo,et al.  Abstract Multiple Specialization and Its Application to Program Parallelization , 1999, J. Log. Program..

[50]  Saumya K. Debray,et al.  A Methodology for Granularity-Based Control of Parallelism in Logic Programs , 1996, J. Symb. Comput..

[51]  Saumya K. Debray,et al.  Task granularity analysis in logic programs , 1990, PLDI '90.

[52]  Peter J. Stuckey,et al.  A Generic Framework for Context-Sensitive Analysis of Modular Programs , 2004, Program Development in Computational Logic.

[53]  Alan Bundy,et al.  Constructing Induction Rules for Deductive Synthesis Proofs , 2006, CLASE.

[54]  Francesca Rossi,et al.  From Eventual to Atomic Locally Atomic CC Programs: A Concurrent Semantics , 1994, ALP.

[55]  Simon L. Peyton Jones,et al.  Report on the programming language Haskell: a non-strict, purely functional language version 1.2 , 1992, SIGP.

[56]  Thom W. Frühwirth,et al.  Theory and Practice of Constraint Handling Rules , 1998, J. Log. Program..

[57]  Mats Carlsson,et al.  Parallel execution of prolog programs: a survey , 2001, TOPL.

[58]  Manuel V. Hermenegildo,et al.  Combined Determination of Sharing and Freeness of Program Variables through Abstract Interpretation , 1991, ICLP.

[59]  Manuel V. Hermenegildo,et al.  The DCG, UDG, and MEL Methods for Automatic Compile-time Parallelization of Logic Programs for Independent And-parallelism , 1990, ICLP.

[60]  John P. Gallagher,et al.  Non-leftmost Unfolding in Partial Evaluation of Logic Programs with Impure Predicates , 2005, LOPSTR.

[61]  Frank Wolter,et al.  Monodic fragments of first-order temporal logics: 2000-2001 A.D , 2001, LPAR.

[62]  Manuel V. Hermenegildo,et al.  Determination of variable dependence information at compile-time through abstract interpretation , 1989 .

[63]  Pierre Lescanne,et al.  Algebraic and Logic Programming , 1988, Lecture Notes in Computer Science.

[64]  Manuel V. Hermenegildo,et al.  A New Module System for Prolog , 2000, Computational Logic.

[65]  Manuel V. Hermenegildo,et al.  Using Global Analysis, Partial Specifications, and an Extensible Assertion Language for Program Validation and Debugging , 1999, The Logic Programming Paradigm.

[66]  Brad J. Cox,et al.  Object-oriented programming ; an evolutionary approach , 1986 .

[67]  Saumya K. Debray,et al.  Transformationbased implementation and optimization of programs exploiting the basic Andorra model. , 1995 .

[68]  Manuel V. Hermenegildo,et al.  Annotation Algorithms for Unrestricted Independent And-Parallelism in Logic Programs , 2008, LOPSTR.

[69]  Manuel V. Hermenegildo,et al.  Effectivness of abstract interpretation in automatic parallelization: a case study in logic programming , 1999, TOPL.

[70]  Alan H. Karp,et al.  A comparison of 12 parallel FORTRAN dialects , 1988, IEEE Software.

[71]  Zoltan Somogyi,et al.  The Execution Algorithm of Mercury, an Efficient Purely Declarative Logic Programming Language , 1996, J. Log. Program..

[72]  Manuel V. Hermenegildo,et al.  A Generic Processor for Program Validation and Debugging , 2000, Analysis and Visualization Tools for Constraint Programming.

[73]  Manuel V. Hermenegildo,et al.  An Improved Continuation Call-Based Implementation of Tabling , 2008, PADL.

[74]  Saumya K. Debray,et al.  Estimating the Computational Cost of Logic Programs , 1994, SAS.

[75]  Manuel V. Hermenegildo,et al.  The CIAO Multi-Dialect Compiler and System: An Experimentation Workbench for Future (C)LP Systems , 1995, APPIA-GULP-PRODE.

[76]  Jan Maluszynski,et al.  Analysis and Visualization Tools for Constraint Programming , 2000, Lecture Notes in Computer Science.

[77]  Manuel V. Hermenegildo,et al.  Extracting Non-Strict Independent And-Parallelism Using Sharing and Freeness Information , 1994, SAS.

[78]  Manuel V. Hermenegildo,et al.  Hiord: A Type-Free Higher-Order Logic Programming Language with Predicate Abstraction , 2004, ASIAN.

[79]  Francesca Rossi,et al.  Partial Order and Contextual Net Semantics for Atomic and Locally Atomic CC Programs , 1998, Sci. Comput. Program..

[80]  Manuel V. Hermenegildo,et al.  A Syntactic Approach to Combining Functional Notation, Lazy Evaluation, and Higher-Order in LP Systems , 2006, FLOPS.

[81]  Germán Puebla,et al.  Poly-controlled partial evaluation , 2006, PPDP '06.

[82]  Manuel V. Hermenegildo,et al.  Some Paradigms for Visualizing Parallel Execution of Logic Programs , 1993, ICLP.

[83]  Nigel P. Topham,et al.  A Limitation Study into Access Decoupling , 1997, Euro-Par.

[84]  Manuel V. Hermenegildo,et al.  An Assertion Language for Constraint Logic Programs , 2000, Analysis and Visualization Tools for Constraint Programming.

[85]  Manuel V. Hermenegildo Some Methodological Issues in the Design of CIAO, a Generic, Parallel Concurrent Constraint Logic Programming System , 1994, PPCP.

[86]  Marco Danelutto,et al.  Euro-Par 2004 Parallel Processing , 2004, Lecture Notes in Computer Science.

[87]  Tom Schrijvers,et al.  Analyses, Optimizations and Extensions of Constraint Handling Rules: Ph.D. Summary , 2005, ICLP.

[88]  Manuel V. Hermenegildo,et al.  Automatic Parallelization of Irregular and Pointer-Based Computations: Perspectives from Logic and Constraint Programming , 1997, Euro-Par.

[89]  K. A. Ross,et al.  Tabled Evaluation with Delaying for General Logic Programs , 1996 .

[90]  Manuel V. Hermenegildo,et al.  An Abstract Interpretation-based Approach to Mobile Code Safety , 2005, COCV@ETAPS.

[91]  Jorge A. Navas,et al.  User-Definable Resource Bounds Analysis for Logic Programs , 2007, ICLP.

[92]  Francesca Rossi,et al.  Towards a Concurrent Semantics based Analysis of CC and CLP , 1994, PPCP.

[93]  James Cheney,et al.  Cyclone: A Safe Dialect of C , 2002, USENIX Annual Technical Conference, General Track.

[94]  Samuele Pedroni,et al.  PyPy's approach to virtual machine construction , 2006, OOPSLA '06.

[95]  Manuel V. Hermenegildo,et al.  Context-Sensitive Multivariant Assertion Checking in Modular Programs , 2006, LPAR.

[96]  Manuel V. Hermenegildo,et al.  Concurrency in Prolog Using Threads and a Shared Database , 1999, ICLP.

[97]  Manuel V. Hermenegildo,et al.  Towards Independent And-Parallelism in CLP , 1996, PLILP.

[98]  Luís Moniz Pereira,et al.  Computational Logic — CL 2000 , 2000, Lecture Notes in Computer Science.

[99]  Robert Cartwright,et al.  Soft typing , 2004, SIGP.

[100]  Manuel V. Hermenegildo,et al.  Towards Description and Optimization of Abstract Machines in an Extension of Prolog , 2006, LOPSTR.

[101]  Fergus Henderson,et al.  Determinism analysis in the Mercury compiler , 1996 .

[102]  Enrico Pontelli,et al.  Integrating an Answer Set Solver into Prolog: ASP-PROLOG , 2005, LPNMR.

[103]  David Scott Warren,et al.  Tabled evaluation with delaying for general logic programs , 1996, JACM.

[104]  Manuel V. Hermenegildo,et al.  Distributed WWW Programming using (Ciao-)Prolog and the PiLLoW library , 2001, Theory Pract. Log. Program..

[105]  Davide Ancona,et al.  RPython: a step towards reconciling dynamically and statically typed OO languages , 2007, DLS '07.

[106]  John P. Gallagher,et al.  Approximating Constraint Logic Programs Using Polymorphic Types and Regular Descriptions , 1995, PLILP.

[107]  Wlodzimierz Drabent,et al.  On the Role of Semantic Approximations on Validation and Diagnosis of Contraint Logic Programs , 1997, AADEBUG.

[108]  Manuel V. Hermenegildo,et al.  Compile-Time Derivation of Variable Dependency Using Abstract Interpretation , 1992, J. Log. Program..

[109]  Manuel V. Hermenegildo,et al.  Towards a High-Level Implementation of Execution Primitives for Unrestricted, Independent And-Parallelism , 2008, PADL.

[110]  Manuel V. Hermenegildo,et al.  Multivariant Non-failure Analysis via Standard Abstract Interpretation , 2004, FLOPS.

[111]  Simon L. Peyton Jones,et al.  A history of Haskell: being lazy with class , 2007, HOPL.

[112]  Gary T. Leavens,et al.  Specification and verification challenges for sequential object-oriented programs , 2007, Formal Aspects of Computing.

[113]  Barbara G. Ryder,et al.  Proceedings of the third ACM SIGPLAN conference on History of programming languages , 2007 .