@mastersthesis {Bacci11,
	title = {An Abstract Interpretation Framework for Semantics and Diagnosis of Lazy Functional-Logic Languages},
	number = {??},
	year = {2012},
	school = {Universit{\`a} di Udine},
	type = {Ph.D.},
	abstract = {This thesis presents a fixed-point semantics for Curry programs which is fully-abstract with respect to the computed (I/O) behavior. Curry is a declarative language that combines in a seamless way features from functional programming (nested expressions, lazy evaluation, higher-order functions) and logic programming (logical variables, partial data structures, built-in search). Among other proposals, the presented semantics has the following pragmatical features: it is goal-independent, condensed and it is a congruence w.r.t. usage (i.e. unions among modules). We also described an abstract interpretation framework for systematically obtain, from this semantics, several abstract semantics which approximate the (I/O) behavior of a Curry program. These kinds of abstract semantics are particularly suitable for developing efficacious semantics-based program manipulation tools. 
To support this claim some applications as been provided: a static analyzer for groundness dependencies, an abstract debugging/diagnosis method, and an automatic method for synthesizing algebraic property-oriented specifications. Moreover, by means of a program transformation into a Curry semantic-equivalent version, these tools also apply to first order purely functional Haskell programs.},
	keywords = {Abstract Interpretation, Curry, Functional-logic Programming},
	author = {Giovanni Bacci}
}
@proceedings {BacciC10absdiag,
	title = {Abstract Diagnosis of First Order Functional Logic Programs},
	journal = {Logic-Based Program Synthesis and Transformation {\textendash} 20th International Symposium {\textendash} Pre-Proceedings},
	volume = {10-14},
	year = {2010},
	pages = {58{\textendash}72},
	edition = {20},
	address = {Hagenberg, Austria},
	abstract = {We present a generic scheme for the abstract debugging of functional-logic programs. We associate to our programs a semantics based on a (continuous) immediate consequence operator, P[[R]], which models correctly the typical cogent features of modern functional-logic languages (non-deterministic, non-strict functions defined by non-confluent programs and call-time choice behaviour). Then, we develop an effective debugging methodology which is based on abstract interpretation: by approximating the intended specification of the semantics of R we derive a finitely terminating bottom-up diagnosis method, which can be used statically. Our debugging framework does not require the user to either provide error symptoms in advance or answer questions concerning program correctness.},
	keywords = {Abstract Diagnosis, Debugging, Declarative Diagnosis, Functional-logic Programming},
	author = {Giovanni Bacci and Marco Comini},
	editor = {Maria Alpuente}
}
@article {BacciC10conc,
	title = {A Compact Goal-Independent Bottom-Up Fixpoint Modeling of the Behaviour of First Order Curry},
	number = {6/2010},
	year = {2010},
	publisher = {Dipartimento di Matematica e Informatica, Universit{\`a} di Udine},
	abstract = {This work is motivated by the fact that a {\textquotedblleft}compact{\textquotedblright} semantics for functional logic languages, which is essential for the development of efficacious semantics-based program manipulation tools (e.g. automatic program analyzers and debuggers), does not exist. The operational or the rewriting logic semantics that are most commonly considered in func- tional logic are unnecessarily oversized, as they contains many {\textquotedblleft}semantically useless{\textquotedblright} elements that can be retrieved from a smaller set of {\textquotedblleft}basic{\textquotedblright} elements. Therefore, in this article, we present a compressed, goal-independent bottom-up fixpoint semantics that is correct and minimal w.r.t. answers computed for Curry expressions.
We believe that the compactness of the semantics makes it particularly suitable for applications. Actually, our semantics can be finite whereas the big-step semantics is generally not, and even when both semantics are infinite, the fixpoint computation of our semantics produces fewer elements at each step.},
	keywords = {Abstract Interpretation, call-time choice semantics, Functional-logic Programming},
	url = {http://www.dimi.uniud.it/comini/Papers/},
	author = {Giovanni Bacci and Marco Comini}
}
@inbook {ABF10,
	title = {Transformation and Debugging of Functional Logic Programs},
	booktitle = {25 Years GULP 2010},
	series = {Lecture Notes in Computer Science},
	year = {2010},
	pages = {271{\textendash}299},
	publisher = {Springer},
	organization = {Springer},
	chapter = {Transformation and Debugging of Functional Logic Programs},
	abstract = {The Italian contribution to 
functional-logic programming has been significant and influential in a number of areas of semantics, and semantics-based program manipulation techniques.
We survey selected topics, with a particular  regard to debugging and 
transformation techniques. These results as usual depend on the
narrowing strategy which is adopted and on the properties satisfied
by the considered programs. In this paper, we restrict ourselves to first-order  functional-logic languages without non-deterministic functions.
We start by describing some basic classical transformation techniques,
namely folding and unfolding.
Then, we recall the
narrowing-driven partial evaluation, which is the first generic algorithm for 
the specialization of functional logic   programs. 
Regarding debugging,
we describe a goal-independent approach to automatic diagnosis and correction 
which applies the immediate consequence operator modeling computed answers
to the diagnosis of bugs in functional logic programs.
A companion bug-correction  program synthesis methodology is 
described that attempts to correct the erroneous
components of the wrong code.},
	keywords = {Debugging, Fold/Unfold Transformations, Functional-logic Programming, Program Transformation},
	author = {Maria Alpuente and Demis Ballis and Moreno Falaschi}
}
@proceedings {ABCF03,
	title = {Correction of Functional Logic Programs},
	journal = {Programming Languages and Systems, 12th European Symposium on Programming, ESOP 2003},
	volume = {2618},
	year = {2003},
	pages = {54{\textendash}68},
	publisher = {Springer},
	abstract = {We propose a new methodology for synthesizing correct
functional logic programs.  We aim to create an integrated development
environment in which it is possible to debug a program and correct
it automatically. We start from a declarative diagnoser that we have developed
previously which allows us
to identify wrong  program rules w.r.t. an intended specification.
Then a bug-correction, program synthesis methodology tries
to correct the erroneous components of the wrong code.
We propose a hybrid, top-down  (unfolding-based)
as well as bottom-up (induction-based), approach
for the automatic correction of functional logic programs
which is driven by a set of evidence examples which are automatically
produced as an outcome by the diagnoser.
The resulting program is proven to be correct and complete
w.r.t. the considered example sets.
Finally, we also provide a prototypical implementation
which we use for an experimental
evaluation of our system.
},
	keywords = {Debugging, Functional-logic Programming, program correction, Program Transformation, Unfolding},
	author = {Maria Alpuente and Demis Ballis and F. Correa and Moreno Falaschi}
}
@proceedings {BFFHR03,
	title = {Cost-Sensitive Diagnosis of Declarative Programs},
	journal = {12th International Workshop on Functional and Constraint Logic Programming, WFLP 2003},
	volume = {86},
	year = {2003},
	pages = {3},
	publisher = {Elsevier},
	abstract = {Diagnosis methods in debugging aim at detecting bugs of a program,
 either by comparing it with a correct specification or 
by the help of an oracle (usually the user herself).
 Debugging techniques for declarative programs usually
 exploit the semantical properties of programs (and specifications)
 and generally try to detect one or more buggy rules.
 In this way, rules are split apart in an absolute way:
 either they are correct or not. However, in many situations, 
not every error has the same consequences, an issue that is 
ignored by classical debugging frameworks.
 In this paper, we generalise debugging by considering a cost function,
 i.e. a function that assigns different cost values to each
 kind of error and different benefit values to each kind of correct response. 
The problem is now redefined as assigning a real-valued probability 
and cost to each rule, by considering each rule more or
 less  guilty of the overall error and cost of the program. 
This makes possible to rank rules rather than only separate
 them between right and wrong. 
Our debugging method is also different from classical approaches
 in that it is probabilistic, i.e. we use a set of ground
 examples to approximate these rankings. },
	keywords = {Cost Matrixes, Cost-sensitive Evaluation, Debugging, Functional-logic Programming},
	author = {Demis Ballis and Moreno Falaschi and C. Ferri and J. Hern{\'a}ndez-Orallo and M. Jos{\'e} Ramirez-Quintana}
}
