next_inactive up previous






Computational Logic:
(Constraint) Logic Programming
Theory, practice, and implementation


The Ciao Programming Environment
and Multiparadigm Programming

Introduction: The Ciao Program Development System


A Parenthesis: Why Ciao?

Introduction: The Ciao Program Development System (Contd.)



The Ciao Development Environment

The Ciao Development Environment

Ciao Prog. Environment: The Graphical Environment

!0.93Image 005splash

Ciao Prog. Environment: The Top Level

!0.93Image 110toplevel

Ciao Prog. Environment: Main Menu (compilation, error location, etc.)

!0.93Image 070ciaomenu

Ciao Program Load

Ciao System Menu (Partial)


(Re)Start Ciao top level (C-c t)
(Re)Load buffer into top level (C-c l)
(Re)Load and check buffer into top level (C-c f)
(Re)Load main and related modules (C-c L)
Make executable from buffer as main (C-c x)
Go to (next) preproc/compiler error msg (C-c `)
Remove error (and dbg) marks in buffers (C-c e)
Set default query (C-c q)
Call default query (C-c Q)
Clear default query
(Un)Set main module (C-c s)
Update syntax-based coloring
Insert script header (C-c I S)
Make object file (.po) from buffer (C-c o)
Make active module from buffer (C-c a)

Ciao Prog. Environment: Error Location

!0.93Image 010errorloc

Debugging in Ciao

Ciao Prog. Environment: The Source Debugger

!0.93Image 020srcdebug

Ciao Debugging Menu (Partial)

(Un)Debug buffer source (C-c d)
Select debug mode (C-c m)
Select multiple buffers for debug (C-c M-m)
Set breakpoint on current literal pred symb (C-c S b)
Remove breakpoint from current literal (C-c S v)
Remove all breakpoints (C-c S n)
Redisplay breakpoints (C-c S l)
Toggle debug mode (jump to bkp or spypt) (C-c S d)
Toggle trace mode (C-c S t)
(Re)Load region (for debug) (C-c r)
(Re)Load predicate (for debug) (C-c p)

Breakpoints

Using the Debugger

Everything transparent to the user within Emacs!

Ciao Prog. Env.: CiaoPP (debugging, optimization, verification, ...)

!0.93Image 100ciaoppmenu

Ciao Preprocessor Menu (Partial)

Analyze buffer (C-c A)
Check buffer assertions (C-c T)
Optimize buffer (C-c O)
Browse analysis/checking/optimizing options (C-c M)
Go to (next) preproc/compiler error msg (C-c `)
Remove error (and dbg) marks in buffers (C-c e)
Show last preprocessor output file (C-c C-v)
Start Ciao preprocessor

Ciao Prog. Environment: Menu for Generating Documentation

!0.93Image 090lpdocmenu

Ciao LPdoc Menu (Partial)


Generate documentation for buffer (C-c D B)
View documentation in selected format (C-c D V)
Change default doc format/visualizer (C-c D F)
Goto (next) preproc/compiler error msg (C-c `)
Remove error (and dbg) marks in buffers (C-c e)
Visit(/create) LPSETTINGS.pl file (C-c D S)
Generate documentation (C-c D G)
Set version control for file (C-c C-a)
Insert changelog entry/increase patch # (C-c C-s)
Increase version number (C-c n)
Go to next changelog entry (C-c C-n)

Ciao Customization Menu (Partial)

Customize all Ciao environment settings
Customize all Ciao system environment settings
Set Ciao toplevel executable
Set Ciao toplevel args
Set Ciao library path
Customize all CiaoPP environment settings
Set Ciao Preprocessor executable
Set Ciao Preprocessor executable args
Customize all LPdoc environment settings
Set LPdoc executable
Set LPdoc executable args
Set LPdoc root working directory
Set LPdoc library path
Customize all Ciao colors/faces

Ciao Help Menu (Partial)

Go to manual page for symbol under cursor (C-c TAB)
Complete symbol under cursor (C-c /)
Ciao system manual
Ciao preprocessor manual
LPdoc automatic documenter manual
Ciao manuals area in info index
List all key bindings
Ciao environment (mode) version (C-c v)

Ciao Prog. Environment: Getting Help (on predicate under cursor)

!0.93Image 030ctxthelp

Ciao Prog. Environment: Accessing Manuals

!0.93Image 080helpmenu

Ciao Prog. Environment: Using Autocompletion

!0.93Image 040completion


The Ciao Module System

The Ciao Module System

Defining modules and exports

Defining modules and exports (Contd.)

Defining modules and exports (Contd.)

Importing from another module

The Ciao Module System (Contd.)

Modular Compilation/Processing

The Generic Code-Processing Framework

The Ciao (Low-level) Compiler

Linking Regimes of Executables, Scripts


Abstract Machine-based: Multiplatform

\includegraphics[angle=0.01 width=0.8\textwidth]{Figs/multiplat}




(Also for: Solaris Sparc, Solaris i386, Linux Sparc, SunOs, IRIX, ...)

Packages

Packages (Cont.)

\includegraphics{Figs/package_arch}


Functional Programming

Functional Notation (A Package!)

Functional Notation (II)

Functional Notation (III)

Functional Notation (IV)


Deriv and its Translation

der(x)      := 1.
der(C)      := 0                 :- number(C).
der(A + B)  := der(A) + der(B).
der(C * A)  := C * der(A)        :- number(C).
der(x ** N) := N * x ** ~(N - 1) :- integer(N), N > 0.
der(x, 1).
der(C, 0) :- 
          number(C).
der(A + B, X + Y) :- 
          der(A, X), der(B, Y).
der(C * A, C * X) :- 
          number(C), der(A, X).
der(x ** N, N * x ** N1) :- 
          integer(N), N > 0, N1 is N - 1.

Examples - Sugar for Append

Functional Notation (V)

Functional Notation (VI)

Examples - Array Access Syntax

:- module(arrays_rt,_,[functional,hiord,assertions,regtypes,isomodes]).

:- pred fixed_array(Dim,Array) :: dim * array
   # "@var{Array} is an array of fixed dimensions @var{Dim}.".
fixed_array([N|Ms],A):- functor(A,a,N), rows(N,Ms,A).
fixed_array([N],   A):- functor(A,a,N).

rows(0,_Ms,_A).
rows(N,Ms,A):- N > 0, arg(N,A,Arg), fixed_array(Ms,Arg), rows(N-1,Ms,A).

:- regtype dim(D) # "@var{D} represents the dimensions of an array.".
dim(D) :- list(D,int).

:- regtype vector(V) # "@var{V} is a one-dimensional fixed-size array.".
vector(V) :- fixed_array([N],V), int(N).

Examples - Array Access Syntax (Contd.)

Examples - Array Access Syntax (Contd.)

Examples - Array Access Syntax (Contd.)

Combining with Constraints, etc.

Functional Notation (VII)

Some Implementation Details

Some Implementation Details

Example of Lazy Functions and Translation (stylized)

:- lazy function fiblist/0.
fiblist := [0, 1 | ~zipWith(add, FibL, ~tail(FibL))]
        :- FibL = fiblist.
 
:- lazy fiblist/1.
fiblist([0, 1 | Rest]) :- 
          fiblist(FibL), 
          tail(FibL, T), 
          zipWith(add, FibL, T, Rest).
fiblist(X) :- 
          freeze(X, 'fiblist_$$lazy$$'(X)).

'fiblist_$$lazy$$'([0, 1 | Rest]) :- 
          fiblist(FibL), 
          tail(FibL, T), 
          zipWith(add, FibL, T, Rest).


Higher Order

Support for Higher-Order Programming

Simple Higher-Order Programming Examples

?- use_package(hiord).
?- P = >(0), P(3).
P = >(0) ? 
yes
?- P = member([1,2]), P(X).
P = member([1,2]),
X = 1 ? ;
P = member([1,2]),
X = 2 ? ;
no
?- call(member([1,2]),X).  
X = 1 ? ;
X = 2 ? ;
no

Simple Higher-Order Programming Examples (Contd.)

?- P = ( _(X,Y):- Y is X+10 ), P(2,R).
P = (''(X,Y):-Y is X+10),
R = 12 ? 
yes
?- call(( _(X,Y):- Y is X+10 ), 2, R).
R = 12 ? 
yes
?-

Extended Meta-Predicate Declarations for HO Programming

A meta-predicate specification for a predicate is the functor of that predicate applied to atoms which represent the kind of module expansion that should be done with the arguments. Possible contents are represented as:

goal

Argument will be a term denoting a goal which will be called. For compatibility `:' can be used as well.

pred(N)

This argument will be a predicate construct to be called by means of call/N.

clause

This argument will be a term denoting a clause.

fact

This argument will be a term denoting a fact.

spec

This argument will be a predicate name (Functor/Arity).

?,+,-,_

These other values denote that this argument is not module expanded.

Simple Higher-Order Programming Examples (Contd.)

Simple Higher-Order Programming Examples (Contd.)

Combining Higher-Order with Functional Notation

Combining Higher-Order with Functional Notation

Some Currying Conventions

Higher-Order Programming (Contd.): Currying Rules in Action

:- set_prolog_flag(multi_arity_warnings,off).

p(X,Y,Z,W,K,L) :- display(p(X,Y,Z,W,K,L)),nl.

?- use_package(hiord).

?- call(p,1,2,3,4,5,6).   -->    p(1,2,3,4,5,6)
?- call(p(1),2,3,4,5,6).  -->    p(2,1,3,4,5,6)
?- call(p(1,2),3,4,5,6).  -->    p(3,1,2,4,5,6)
?- call(p(1,2,3),4,5,6).  -->    p(4,1,2,3,5,6)
?- call(p(1,2,3,4),5,6).  -->    p(5,1,2,3,4,6)
?- call(p(1,2,3,4,5),6).  -->    p(6,1,2,3,4,5)
?- call(p(1,2,3,4,5,6)).  -->    p(1,2,3,4,5,6)


Alternative Computation Rules

Using Other Computation Rules

Breadth-First

Breadth-First Example I

 
     :- module(chain, [test/1], [bf]).
     
     test(df) :- chain(a,d).     % Loops with usual depth first rule
     test(bf) :- bfchain(a,d).
     
     bfchain(X,X) <- .
     bfchain(X,Y) <- arc(X,Z), bfchain(Z,Y).
     
     chain(X,X).
     chain(X,Y):- arc(X,Z), chain(Z,Y).
     
     arc(a,b).   arc(a,d).
     arc(b,c).   arc(c,a).

Breadth-First Example II

 
:- module(chain_bfall, _, ['bf/bfall']).

test :- chain(a,d).

chain(X,X).
chain(X,Y) :- arc(X,Z), chain(Z,Y).

arc(a,b).
arc(a,d).
arc(b,c).
arc(c,a).

Breadth-First Example III

 
     :- module(sublist, [test/1], ['bf/af']).
     
     test(df) :- sublist_df([a],[b]).  % loops with depth first rule.
     test(bf) :- sublist_bf([a],[b]).  % loops with normal breadth-first
     
     sublist_df(S,L) :- append(_,S,Y), append(Y,_,L).

     sublist_bf(S,L) <- append(_,S,Y), append(Y,_,L).
     
     append([], L, L) <- .
     append([X|Xs], L, [X|Ys]) <- append(Xs, L, Ys).

Iterative-Deepening


Constraint Programming

Constraints


CLP example


Another CLP example



Object-Oriented Programming

Object-Oriented Features: O'Ciao


Ciao Instantiable Modules $\rightarrow$ Classes/Objects


:- class(deck,[addcard/1,drawcard/1]).

:- dynamic card/2.
% initial state
card(1,hearts).
card(8,diamonds).

addcard(card(X,Y))  :- asserta(card(X,Y)).
drawcard(card(X,Y)) :- retract(card(X,Y)).


:- module(main,[main/0],[objects]).
:- use_class(deck).

main :- 
     S1 new deck,
     S2 new deck,
     S1:drawcard(C),
     S2:addcard(C).

Ciao Instantiable Modules $\rightarrow$ Classes/Objects (Contd.)

O'Ciao: Defining Classes

Another Example of a Class

:- class(stack,[push/1,pop/1,top/1,is_empty/0]).

% Attribute
:- data storage/1.

% Methods
push(Item) :- asserta_fact(storage(Item)).

pop(Item) :- retract_fact(storage(Item)).

top(Top) :- storage(Top), !.

is_empty :- \+ storage(_).

O'Ciao: Using Classes

O'Ciao: Other Features


Other Extensions

Records package (named arguments)


Persistent Predicates

Persistent Predicates Example I

Persistent Predicates Example II

  • Example: program configuration files, which need to be read and written for every run (e.g., ~/.XXXrc files).
  • Not a difficult problem, but certainly a hassle.
  • Normally manual handling (read/parse/write) of the file.
\includegraphics[scale=0.6]{Figs/conf_file.eps}


\includegraphics[scale=0.6]{Figs/perspred_ciao.eps}
  • Alternitive: use persistent facts.
  • State that the facts will live in, e.g., ~/.XXXrc.
  • Access is automatic and update as simple as using assert and retract.


Concurrency and Distribution

Basic Concurrency

A Simple Example



:- concurrent proceed/1.

waitf:-
     retract_fact(proceed(X)),
     display(proceeding(X)), 
     nl.
wait_facts:-
     eng_call(waitf, create, create),
     eng_call(waitf, create, create),
     eng_call(waitf, create, create),
     asserta_fact(proceed(1)),
     asserta_fact(proceed(2)),
     asserta_fact(proceed(3)).



A Threaded TCP/IP-based Server



:- concurrent conn/1.

wait_for_queries(Socket):-
     repeat,
     socket_accept(Socket, Stream),
     assertz_fact(conn(Stream)),
     fail.
handle_conn:-
     retract_fact(conn(Stream)),
     read(Stream, Number1),
     read(Stream, Number2),
     Result is Number1 + Number2,
     write(Stream, Result),
     close(Stream),
     fail.


Higher-Level Concurrency Primitives

Higher-Level Concurrency Primitives (Contd.)

Distributed Execution

Distributed Execution (Contd.)

Active Modules / Active Objects

Using Active Modules: An Example

Using Active Modules: An Example

Active Objects, Code, and Computation Mobility


Web Programming

Web Programming

Form Producer/Handler Example

main(_) :-
    get_form_input(Input),
    get_form_value(Input,person_name,Name),
    response(Name,Response),
    file_to_string('html_template.html', Contents),
    html_template(Contents, HTML_terms, [response = Response]),
    output_html([cgi_reply|HTML_terms]).

response(Name, []) :- form_empty_value(Name), !.
response(Name, ['Phone number for ',b(Name),' is ',Info, --]) :-
        phone(Name,Info), !.
response(Name, ['No phone number available for ',b(Name), '.', --]).

%% Database
phone('Hanna', '613 460 069').
(...)


Support for Auto-Documentation (LPdoc)

LPdoc: the Ciao Automatic Documentation System

LPdoc Overall operation

\epsfig{figure=/home/logalg/public_html/slides/Figs/lpdoc_io_new.eps,width=\textwidth}

LPdoc Inputs

Assertions

Assertions (Contd.)

Comments

Structure of generated documents


Documentation of predicates, props, etc.


The Ciao Assertion Language

Introduction

Assertions

Properties


:- regtype list/1.                    | :- regtype list/1. 
list([]).                             | list :=  [] | [_|~list].
list([_|Y]) :- list(Y).               |__________________________________
______________________________________| :- regtype int/1 + impl_defined.
:- prop sorted/1.                     |__________________________________
sorted([]).                           | :- regtype peano_int/1.
sorted([_]).                          | peano_int(0).
sorted([X,Y|Z]) :- X>Y, sorted([Y|Z]).| peano_int(s(X)) :- peano_int(X).

Basic Predicate Assertions: Success

Basic Predicate Assertions: Calls

Basic Predicate Assertions: Comp

Compound Predicate Assertions: Pred Assertions


Example of a Program with Assertions


:- module(qsort,[qsort/2],[assertions,regtypes]).

:- pred qsort(A,B) : list(A) => sorted(B). 
qsort([],[]).
qsort([X|L],R) :-
        partition(L,X,L1,L2),
        qsort(L2,R2), qsort(L1,R1), 
        append(R1,[X|R2],R).

:- pred partition(A,B,C,D) : list(A).
partition([],B,[],[]).
partition([E|R],C,[E|Left1],Right):- E < C, !, 
        partition(R,C,Left1,Right).
partition([E|R],C,Left,[E|Right1]):- E >= C, 
        partition(R,C,Left,Right1).

Example of a Program with Assertions (Cont.)

:- prop sorted/1.

sorted([]).                                        
sorted([_]).                                       
sorted([X,Y|L]):- X =< Y, sorted([Y|L]).           

:- regtype list/1.

list([]).       
list([_|L]):-   
        list(L).

Same Example in mixed Logic/Functional Notation


:- module(qsort,[qsort/2],[functions,assertions,regtypes]).
:- use_module(library(lists),[append/3]).

:- pred qsort(A,B) : list(A) => sorted(B). 
qsort([])    := [].
qsort([X|L]) := ~append(qsort(L1),[X|qsort(L2)]) :- partition(L,X,L1,L2).

:- pred partition(A,B,C,D) : list(A).
partition([],_,[],[]).
partition([E|R],C,[E|Left1],Right):- E < C, !, partition(R,C,Left1,Right).
partition([E|R],C,Left,[E|Right1]):- E >= C,   partition(R,C,Left,Right1).

:- prop sorted/1. 
sorted := [] | [_]. 
sorted := [X,Y|L] :- X=<Y, sorted([Y|L]).           

:- regtype list/1. list := [] | [_|~list].

Syntactic Sugar

Mode Definitions ('Property Macros')

Mode Definitions (Cont.)

Parametric Mode Definitions

Documentation

Program Point Assertions

Assertion ``Status'' (e.g., Compiler Output)

Assertion ``Status'' (e.g., Compiler Output)

Guiding Analysis

Compatibilty and Instantiation

Compatibilty and Instantiation

Some Final Comments


The Ciao Preprocessor (CiaoPP)

CiaoPP: The Ciao System Preprocessor



Other Issues

Other Issues

 $$
FD constraint solver.
 $$
Full implementation of distribution [16].
 $$
Fully transparent access to databases (bypassing schizoid DB characteristics).
 $$
Compilation to C [36], abstract machine specialization.
 $$
Making expansion rule order transparent.
 $$
KUL CHR [20] supported.
 $$
Improved delay (when, freeze, ...) primitives.
 $$
Efficient constructive negation [38].
+
Many issues related to program analysis and transformation (CiaoPP).

 $$
...

External Collaborations and Funding


Downloading the system(s)

»²¹حت¸¸¥

1
E. Albert, P. Arenas, G. Puebla, and M. Hermenegildo.
Reduced Certificates for Abstraction-Carrying Code.
In 22nd International Conference on Logic Programming (ICLP 2006), number 4079 in LNCS, pages 163-178. Springer-Verlag, August 2006.

2
E. Albert, G. Puebla, and M. Hermenegildo.
Abstraction-Carrying Code.
In Proc. of LPAR'04, number 3452 in LNAI, pages 380-397. Springer-Verlag, 2005.

3
F. Bueno, D. Cabeza, M. Carro, M. Hermenegildo, P. López-García, and G. Puebla.
The Ciao Prolog System. Reference Manual (v1.8).
The Ciao System Documentation Series-TR CLIP4/2002.1, School of Computer Science, Technical University of Madrid (UPM), May 2002.
System and on-line version of the manual available at http://www.ciaohome.org.

4
F. Bueno, D. Cabeza, M. Hermenegildo, and G. Puebla.
Global Analysis of Standard Prolog Programs.
In European Symposium on Programming, number 1058 in LNCS, pages 108-124, Sweden, April 1996. Springer-Verlag.

5
F. Bueno, M. García de la Banda, and M. Hermenegildo.
Effectiveness of Abstract Interpretation in Automatic Parallelization: A Case Study in Logic Programming.
ACM Transactions on Programming Languages and Systems, 21(2):189-238, March 1999.

6
F. Bueno, M. García de la Banda, M. Hermenegildo, K. Marriott, G. Puebla, and P. Stuckey.
A Model for Inter-module Analysis and Optimizing Compilation.
In Logic-based Program Synthesis and Transformation, number 2042 in LNCS, pages 86-102. Springer-Verlag, March 2001.

7
I. Caballero, D. Cabeza, S. Genaim, J.M. Gomez, and M. Hermenegildo.
persdb_sql: SQL Persistent Database Interface.
Technical Report CLIP10/98.0, December 1998.

8
D. Cabeza and M. Hermenegildo.
Implementing Distributed Concurrent Constraint Execution in the CIAO System.
In Proc. of the AGP'96 Joint conference on Declarative Programming, pages 67-78, San Sebastian, Spain, July 1996. U. of the Basque Country.
Available from http://www.cliplab.org/.

9
D. Cabeza and M. Hermenegildo.
WWW Programming using Computational Logic Systems (and the PiLLoW/Ciao Library).
In Proceedings of the Workshop on Logic Programming and the WWW at WWW6, San Francisco, CA, April 1997.

10
D. Cabeza and M. Hermenegildo.
A New Module System for Prolog.
In International Conference on Computational Logic, CL2000, number 1861 in LNAI, pages 131-148. Springer-Verlag, July 2000.

11
D. Cabeza and M. Hermenegildo.
The Ciao Modular, Standalone Compiler and Its Generic Program Processing Library.
In Special Issue on Parallelism and Implementation of (C)LP Systems, volume 30(3) of Electronic Notes in Theoretical Computer Science. Elsevier - North Holland, March 2000.

12
D. Cabeza and M. Hermenegildo.
Distributed WWW Programming using (Ciao-)Prolog and the PiLLoW Library.
Theory and Practice of Logic Programming, 1(3):251-282, May 2001.

13
D. Cabeza, M. Hermenegildo, and J. Lipton.
Hiord: A Type-Free Higher-Order Logic Programming Language with Predicate Abstraction.
In Ninth Asian Computing Science Conference (ASIAN'04), number 3321 in LNCS, pages 93-108. Springer-Verlag, December 2004.

14
D. Cabeza, M. Hermenegildo, and S. Varma.
The PiLLoW/Ciao Library for INTERNET/WWW Programming using Computational Logic Systems, May 1999.
See http://www.cliplab.org/Software/pillow/pillow.html.

15
M. Carro and M. Hermenegildo.
Concurrency in Prolog Using Threads and a Shared Database.
In 1999 International Conference on Logic Programming, pages 320-334. MIT Press, Cambridge, MA, USA, November 1999.

16
M. Carro and M. Hermenegildo.
A simple approach to distributed objects in prolog.
In Colloquium on Implementation of Constraint and LOgic Programming Systems (ICLP associated workshop), Copenhagen, July 2002.

17
A. Casas, D. Cabeza, and M. Hermenegildo.
A Syntactic Approach to Combining Functional Notation, Lazy Evaluation and Higher-Order in LP Systems.
In Eighth International Symposium on Functional and Logic Programming (FLOPS'06), Fuji Susono (Japan), April 2006.

18
S. K. Debray, P. López-García, M. Hermenegildo, and N.-W. Lin.
Lower Bound Cost Estimation for Logic Programs.
In 1997 International Logic Programming Symposium, pages 291-305. MIT Press, Cambridge, MA, October 1997.

19
S.K. Debray, P. López-García, and M. Hermenegildo.
Non-Failure Analysis for Logic Programs.
In 1997 International Conference on Logic Programming, pages 48-62, Cambridge, MA, June 1997. MIT Press, Cambridge, MA.

20
Thom Frühwirth.
Theory and Practice of Constraint Handling Rules.
Journal of Logic Programming, 37(1-3), October 1998.

21
J.M. Gomez, D. Cabeza, and M. Hermenegildo.
persdb: Persistent Database Interface.
Technical Report CLIP9/98.0, December 1998.

22
M. Hermenegildo.
A Documentation Generator for (C)LP Systems.
In International Conference on Computational Logic, CL2000, number 1861 in LNAI, pages 1345-1361. Springer-Verlag, July 2000.

23
M. Hermenegildo, F. Bueno, D. Cabeza, M. Carro, M. García de la Banda, P. López-García, and G. Puebla.
The CIAO Multi-Dialect Compiler and System: An Experimentation Workbench for Future (C)LP Systems.
In Parallelism and Implementation of Logic and Constraint Logic Programming, pages 65-85. Nova Science, Commack, NY, USA, April 1999.

24
M. Hermenegildo, F. Bueno, G. Puebla, and P. López-García.
Program Analysis, Debugging and Optimization Using the Ciao System Preprocessor.
In 1999 Int'l. Conference on Logic Programming, pages 52-66, Cambridge, MA, November 1999. MIT Press.

25
M. Hermenegildo, D. Cabeza, and M. Carro.
Using Attributed Variables in the Implementation of Concurrent and Parallel Logic Programming Systems.
In Proc. of the Twelfth International Conference on Logic Programming, pages 631-645. MIT Press, June 1995.

26
M. Hermenegildo, G. Puebla, and F. Bueno.
Using Global Analysis, Partial Specifications, and an Extensible Assertion Language for Program Validation and Debugging.
In K. R. Apt, V. Marek, M. Truszczynski, and D. S. Warren, editors, The Logic Programming Paradigm: a 25-Year Perspective, pages 161-192. Springer-Verlag, July 1999.

27
M. Hermenegildo, G. Puebla, F. Bueno, and P. López-García.
Abstract Verification and Debugging of Constraint Logic Programs.
In Recent Advances in Constraints, number 2627 in LNCS, pages 1-14. Springer-Verlag, January 2003.

28
M. Hermenegildo, G. Puebla, F. Bueno, and P. López-García.
Program Development Using Abstract Interpretation (and The Ciao System Preprocessor).
In 10th International Static Analysis Symposium (SAS'03), number 2694 in LNCS, pages 127-152. Springer-Verlag, June 2003.

29
M. Hermenegildo, G. Puebla, F. Bueno, and P. López-García.
Integrated Program Debugging, Verification, and Optimization Using Abstract Interpretation (and The Ciao System Preprocessor).
Science of Computer Programming, 58(1-2):115-140, October 2005.

30
M. Hermenegildo, G. Puebla, K. Marriott, and P. Stuckey.
Incremental Analysis of Logic Programs.
In International Conference on Logic Programming, pages 797-811. MIT Press, June 1995.

31
M. Hermenegildo, G. Puebla, K. Marriott, and P. Stuckey.
Incremental Analysis of Constraint Logic Programs.
ACM Transactions on Programming Languages and Systems, 22(2):187-223, March 2000.

32
C. Holzbaur.
Metastructures vs. Attributed Variables in the Context of Extensible Unification.
In 1992 International Symposium on Programming Language Implementation and Logic Programming, pages 260-268. LNCS631, Springer Verlag, August 1992.

33
C. Holzbaur.
SICStus 2.1/DMCAI Clp 2.1.1 User's Manual.
University of Vienna, 1994.

34
P. López-García and M. Hermenegildo.
Efficient Term Size Computation for Granularity Control.
In International Conference on Logic Programming, pages 647-661, Cambridge, MA, June 1995. MIT Press, Cambridge, MA.

35
P. López-García, M. Hermenegildo, and S. K. Debray.
A Methodology for Granularity Based Control of Parallelism in Logic Programs.
Journal of Symbolic Computation, Special Issue on Parallel Symbolic Computation, 22:715-734, 1996.

36
J. Morales and M. Carro.
Improving the Compilation of Prolog to C Using Type Information: Preliminary Results.
In M. Carro, C. Vaucheret, and K.-K. Lau, editors, Proceedings of the CBD 2002 / ITCLS 2002 CoLogNet Joint Workshop, pages 167-180, School of Computer Science, Technical University of Madrid, September 2002. Facultad de Informatica.

37
J. Morales, M. Carro, G. Puebla, and M. Hermenegildo.
A generator of efficient abstract machine implementations and its application to emulator minimization.
In P. Meseguer and J. Larrosa, editors, International Conference on Logic Programming, LNCS. Springer Verlag, October 2005.

38
S. Muñoz, J.J. Moreno-Navarro, and M. Hermenegildo.
Efficient Negation Using Abstract Interpretation.
In Proc. of the Eigth International Conference on Logic Programming and Automated Reasoning, LNAI. Springer-Verlag, December 2001.

39
J. Navas, F. Bueno, and M. Hermenegildo.
Efficient top-down set-sharing analysis using cliques.
In Eight International Symposium on Practical Aspects of Declarative Languages, number 2819 in LNCS, pages 183-198. Springer-Verlag, January 2006.

40
A. Pineda and M. Hermenegildo.
O'Ciao: An Object Oriented Programming Model for (Ciao) Prolog.
Technical Report CLIP 5/99.0, Facultad de Informática, UPM, July 1999.

41
G. Puebla, F. Bueno, and M. Hermenegildo.
A Generic Preprocessor for Program Validation and Debugging.
In P. Deransart, M. Hermenegildo, and J. Maluszynski, editors, Analysis and Visualization Tools for Constraint Programming, number 1870 in LNCS, pages 63-107. Springer-Verlag, September 2000.

42
G. Puebla, F. Bueno, and M. Hermenegildo.
An Assertion Language for Constraint Logic Programs.
In P. Deransart, M. Hermenegildo, and J. Maluszynski, editors, Analysis and Visualization Tools for Constraint Programming, number 1870 in LNCS, pages 23-61. Springer-Verlag, September 2000.

43
G. Puebla, F. Bueno, and M. Hermenegildo.
Combined Static and Dynamic Assertion-Based Debugging of Constraint Logic Programs.
In Logic-based Program Synthesis and Transformation (LOPSTR'99), number 1817 in LNCS, pages 273-292. Springer-Verlag, March 2000.

44
G. Puebla and M. Hermenegildo.
Abstract Multiple Specialization and its Application to Program Parallelization.
J. of Logic Programming. Special Issue on Synthesis, Transformation and Analysis of Logic Programs, 41(2&3):279-316, November 1999.

45
G. Puebla and M. Hermenegildo.
Abstract Specialization and its Applications.
In ACM Partial Evaluation and Semantics based Program Manipulation (PEPM'03), pages 29-43. ACM Press, June 2003.
Invited talk.


next_inactive up previous
Last modification: Mon Feb 26 17:16:54 CET 2007 <webmaster@clip.dia.fi.upm.es>[CLIP] [FIM] [UNM]