Showing papers on "Functional logic programming published in 2016"

Behavioral Types in Programming Languages

Abstract: A recent trend in programming language research is to use behavioral type theory to ensure various correctness properties of large-scale, communication-intensive systems. Behavioral types encompass concepts such as interfaces, communication protocols, contracts, and choreography. The successful application of behavioral types requires a solid understanding of several practical aspects, from their representation in a concrete programming language, to their integration with other programming constructs such as methods and functions, to design and monitoring methodologies that take behaviors into account. Behavioral Types in Programming Languages provides the reader with the first comprehensive overview of the state of the art of these practical aspects, which are summarized as the pragmatics of behavioral types. Each section covers a particular programming paradigm or methodology, providing an ideal reference for programming languages researchers interested the topic, and in identifying the areas as yet unexplored.

Practical Probabilistic Programming

Abstract: Probabilistic programming promises to make probabilistic modeling easier by making it possible to create models using the power of programming languages, and by applying general-purpose algorithms to reason about models. We present a new probabilistic programming language named Figaro that was designed with practicality and usability in mind. Figaro can represent models naturally that have been difficult to represent in other languages, such as probabilistic relational models and models with undirected relationships with arbitrary constraints. An important feature is that the Figaro language and reasoning algorithms are embedded as a library in Scala. We illustrate the use of Figaro through a case study.

Design and Implementation of Probabilistic Programming Language Anglican

Abstract: Anglican is a probabilistic programming system designed to interoperate with Clojure and other JVM languages. We introduce the programming language Anglican, outline our design choices, and discuss in depth the implementation of the Anglican language and runtime, including macro-based compilation, extended CPS-based evaluation model, and functional representations for probabilistic paradigms, such as a distribution, a random process, and an inference algorithm.We show that a probabilistic functional language can be implemented efficiently and integrated tightly with a conventional functional language with only moderate computational overhead. We also demonstrate how advanced probabilistic modelling concepts are mapped naturally to the functional foundation.

Handbook Of Logic In Artificial Intelligence And Logic Programming

Abstract: Thank you for reading handbook of logic in artificial intelligence and logic programming. As you may know, people have look numerous times for their favorite books like this handbook of logic in artificial intelligence and logic programming, but end up in malicious downloads. Rather than enjoying a good book with a cup of coffee in the afternoon, instead they are facing with some malicious bugs inside their laptop.

Integration of AI and OR Techniques in Constraint Programming

Abstract: Implied literals detection has been shown to improve performance of Boolean satisfiability (SAT) solvers for certain problem classes, in particular when applied in an efficient dynamic manner on learned clauses derived from conflicts during backtracking search. We explore this technique further and extend it to mixed integer linear programs (MIPs) in the context of conflict constraints. This results in stronger inference from clique tables and implication tables already commonly maintained by MIP solvers. Further, we extend the technique to knapsack covers and propose an efficient implementation. Our experiments show that implied literals, in particular through stronger inference from knapsack covers, improve the performance of the MIP engine of IBM ILOG CPLEX Optimization Studio 12.5, especially on harder instances.

Programming Language Pragmatics

Abstract: Thank you very much for reading programming language pragmatics. Maybe you have knowledge that, people have look numerous times for their favorite novels like this programming language pragmatics, but end up in harmful downloads. Rather than enjoying a good book with a cup of coffee in the afternoon, instead they juggled with some harmful bugs inside their desktop computer. programming language pragmatics is available in our digital library an online access to it is set as public so you can get it instantly. Our book servers hosts in multiple locations, allowing you to get the most less latency time to download any of our books like this one. Merely said, the programming language pragmatics is universally compatible with any devices to read.

The Answer Set Programming Paradigm

Abstract: In this article, we give an overview of the answer set programming paradigm, explain its strengths, and illustrate its main features in terms of examples and an application problem.

What's hot in the Answer Set Programming competition

Abstract: Answer Set Programming (ASP) is a declarative programming paradigm with roots in logic programming, knowledge representation, and non-monotonic reasoning. The ASP competition series aims at assessing and promoting the evolution of ASP systems and applications. Its growing range of challenging application-oriented benchmarks inspires and showcases continuous advancements of the state of the art in ASP.

Probabilistic logic programming on the web

Abstract: We present the web application 'cplint on SWI-Prolog for SHaring that allows the user to write SWISH' Probabilistic Logic Programs and submit the computation of the probability of queries with a web browser. The application is based on SWISH, a web framework for Logic Programming. SWISH is based on various features and packages of SWI-Prolog, in particular, its web server and its Pengine library, that allow to create remote Prolog engines and to pose queries to them. In order to develop the web application, we started from the PITA system, which is included in cplint, a suite of programs for reasoning over Logic Programs with Annotated Disjunctions, by porting PITA to SWI-Prolog. Moreover, we modified the PITA library so that it can be executed in a multi-threading environment. Developing 'cplint on SWISH' also required modification of the JavaScript SWISH code that creates and queries Pengines. 'cplint on SWISH' includes a number of examples that cover a wide range of domains and provide interesting applications of Probabilistic Logic Programming. By providing a web interface to cplint, we allow users to experiment with Probabilistic Logic Programming without the need to install a system, a procedure that is often complex, error prone, and limited mainly to the Linux platform. In this way, we aim to reach out to a wider audience and popularize Probabilistic Logic Programming. Copyright © 2015 John Wiley & Sons, Ltd.

Gradually Learning Programming Supported by a Growable Programming Language

Abstract: Learning programming is a difficult task. The learning process is particularly disorienting when you are approaching programming for the first time. As a student you are exposed to several new concepts (control flow, variable, etc. but also coding, compiling, etc.) and new ways to think (algorithms). Teachers try to expose the students gradually to the new concepts by presenting them one-by-one but the tools at student’s disposal do not help: they provide support, suggestion, and documentation for the full programming language of choice hampering the teacher’s efforts. On the other side, students need to learn real languages and not didactic languages. In this paper, we propose an approach to gradually teach programming supported by a programming language that grows—together with its implementation—along with the number of concepts presented to the students. The proposed approach can be applied to the teaching of any programming language, and some experiments with Javascript are reported.

Shift Design with Answer Set Programming

Abstract: Answer Set Programming (ASP) is a powerful declarative programming paradigm that has been successfully applied to many different domains. Recently, ASP has also proved successful for hard optimization problems like course timetabling. In this paper, we approach another important task, namely, the shift design problem, aiming at an alignment of a minimum number of shifts in order to meet required numbers of employees (which typically vary for different time periods) in such a way that over- and understaffing is minimized. We provide an ASP encoding of the shift design problem, which, to the best of our knowledge, has not been addressed by ASP yet.

Concurrent Programming Algorithms Principles And Foundations

Abstract: Thank you for reading concurrent programming algorithms principles and foundations. As you may know, people have look hundreds times for their favorite books like this concurrent programming algorithms principles and foundations, but end up in infectious downloads. Rather than reading a good book with a cup of tea in the afternoon, instead they are facing with some harmful virus inside their computer.

Datafun: a functional Datalog

Abstract: Datalog may be considered either an unusually powerful query language or a carefully limited logic programming language. Datalog is declarative, expressive, and optimizable, and has been applied successfully in a wide variety of problem domains. However, most use-cases require extending Datalog in an application-specific manner. In this paper we define Datafun, an analogue of Datalog supporting higher-order functional programming. The key idea is to track monotonicity with types.

Computation by interaction for space-bounded functional programming

Abstract: When programming with sublinear space constraints one often needs to use special implementation techniques even for simple tasks, such as function composition. In this paper, we study how such implementation techniques can be supported in a functional programming language. Our approach is based on modelling computation by interaction using the Int construction of Joyal, Street & Verity. We apply this construction to a term model of a first-order programming language and use the resulting structure to derive the functional programming language intml. Intml can be understood as a programming language simplification of Stratified Bounded Affine Logic. We formulate intml by means of a type system inspired by Baillot & Terui's Dual Light Affine Logic. We show that it captures the complexity classes flogspace and nflogspace. We illustrate its expressiveness by showing how typical graph algorithms, such a test for acyclicity in undirected graphs, can be represented.

Answer Sets and the Language of Answer Set Programming

Abstract: Answer set programming is a declarative programming paradigm based on the answer set semantics of logic programs. This introductory article provides the mathematical background for the discussion of answer set programming in other contributions to this special issue.

Examples of Algorithmic Thinking in Programming Education

Abstract: Algorithmic thinking and problem solving strategies are essential principles of computer science. Programming education should reflect this and emphasize different aspects of these principles rather than syntactical details of a concrete programming language. In this paper, we identify three major aspects of algorithmic thinking as objectives of our curricula: the notion of a formal language to express algorithms, abstraction and automation to transfer proven strategies to new instances, and the limits of practical computability. The primary contribution of this paper are three examples that illustrate how general aspects of algorithmic thinking can be incorporated into programming classes. The examples are taken from our teaching materials for K-12 and university non-majors and have been extensively tested in the field.

LAWRIS: A rule-based arduino programming system for young students

Abstract: Since Arduino is the main entry-level platform to the world of electronic circuits and systems, there are many programming environments that try to ease the burden of Arduino textual programming on young primary students. Although block-based, most of these environments retain the imperative structures of textual programming languages, which are not easily comprehensible by such students. The proposed, in this paper, Learning-Arduino-With-Rules Introductory System (LAWRIS) tries to tackle this problem by adopting a rule-based approach: an Arduino-based pre-specified system can be programmed by constructing rules with very simple and intuitive jigsaw pieces, in a visual, web-based environment. Contrary to other programming environments for Arduino, the main logic of LAWRIS is implemented on the board side and only a configuration string is downloaded to it. Thus, LAWRIS features fast responses to both circuit input changes and program modifications, a very important characteristic for young students. It also imposes minimal overhead on the host system, allows web access of the programming environment, and has very low hardware cost.

A Longitudinal Analysis of the Reid List of First Programming Languages

Abstract: Throughout the 1990s, Richard Reid of Michigan State University maintained a list showing the first programming language used in introductory programming courses taken by computer science and information systems majors; it was updated for several years afterwards with the most recent update done in 2011. This is a follow-up to that last update of the Reid List. A newer list is shown and compared to the results of four years ago. The changes in popularity of different programming languages are discussed as well as some of the reasons for these changes.

Probabilistic programming language and its incremental evaluation

Abstract: This system description paper introduces the probabilistic programming language Hakaru10, for expressing, and performing inference on (general) graphical models. The language supports discrete and continuous distributions, mixture distributions and conditioning. Hakaru10 is a DSL embedded in Haskell and supports Monte-Carlo Markov Chain (MCMC) inference.

Operational methods in semantics

Abstract: The focus of these lecture notes is on abstract models and basic ideas and results that relate to the operational semantics of programming languages largely conceived. The approach is to start with an abstract description of the computation steps of programs and then to build on top semantic equivalences, specification languages, and static analyses. While other approaches to the semantics of programming languages are possible, it appears that the operational one is particularly effective in that it requires a moderate level of mathematical sophistication and scales reasonably well to a large variety of programming features. In practice, operational semantics is a suitable framework to build portable language implementations and to specify and test program properties. It is also used routinely to tackle more ambitious tasks such as proving the correctness of a compiler or a static analyzer. These lecture notes contain a selection of the material taught by the author over several years in courses on the semantics of programming languages, foundations of programming, compilation, and concurrency theory. They are oriented towards master students interested in fundamental research in computer science. The reader is supposed to be familiar with the main programming paradigms (imperative, functional, object-oriented,...) and to have been exposed to the notions of concurrency and synchronization as usually discussed in a course on operating systems. The reader is also expected to have attended introductory courses on automata, formal languages, mathematical logic, and compilation of programming languages. Our goal is to provide a compact reference for grasping the basic ideas of a rapidly evolving field. This means that we concentrate on the simple cases and we give a self-contained presentation of the proof techniques. Following this approach, we manage to cover a rather large spectrum of topics within a coherent terminology and to shed some light, we hope, on the connections among apparently different formalisms.

Interaction protocols in the JADEL programming language

Abstract: This paper presents the support for interaction protocols that has been recently added to the JADEL programming language. JADEL is an agent-oriented programming language designed to ease the development of JADE agents and multi-agent systems by offering general-purpose agent-oriented abstractions to the programmer. The first part of the paper presents JADEL and motivates the need for a new agent-oriented programming language. Then, the agent-oriented abstractions that JADEL has been providing since its first version-namely agents, behaviours and communication ontologies-are described. The new support for interaction protocols is finally presented, and a simple example of a JADEL multi-agent system that uses interaction protocols is reported. The paper is concluded with an overview of the current state of JADEL and related tools.

Source code metrics for programmable logic controller (PLC) ladder diagram (LD) visual programming language

Abstract: The IEC 611131-3, an open international standard for Programmable Logic Controllers (PLC) defines several domain specific languages for industrial and process automation. Domain specific languages have several features, programming constructs and notations which are different than general purpose languages and hence the traditional source code metrics for general purpose programming languages cannot be directly applied to domain specific languages for writing control programs in the area of industrial automation. We propose source code level metrics to measure size, vocabulary, cognitive complexity and testing complexity of a visual Programmable Logic Controller (PLC) programming language. We present metrics for Ladder Diagram (LD) programming language which is one of the five languages defined in the IEC 61131-3 standard. The proposed metric is based on factors like number of distinct operators and operands, total number of operators and operands, number of rungs, weights of different basic control structures, structure of the program and control flow. We apply Weyukur's property to validate the metrics and evaluate the number of properties satisfied by the proposed metric.

CurryCheck: Checking Properties of Curry Programs

Abstract: We present CurryCheck, a tool to automate the testing of programs written in the functional logic programming language Curry. CurryCheck executes unit tests as well as property tests which are parameterized over one or more arguments. CurryCheck tests properties by systematically enumerating test cases so that, for smaller finite domains, CurryCheck can actually prove properties. Unit tests and properties can be defined in a Curry module without being exported. Thus, they are also useful to document the intended semantics of the source code. Furthermore, CurryCheck also supports the automated checking of specifications and contracts occurring in source programs. Hence, CurryCheck is a useful tool that contributes to the property- and specification-based development of reliable and well tested declarative programs.

Logic programming for modeling morality

Abstract: This paper investigates the appropriateness of LP-based reasoning to machine ethics, an interdisciplinary field of inquiry that emerges from the need of imbuing autonomous agents with the capacity for moral decision making. The first contribution of the paper is that of identifying morality viewpoints, as studied in moral philosophy and psychology, which are amenable to computational modeling, and then mapping them to appropriate LP-based reasoning features. The identified viewpoints are covered by two morality themes: moral permissibility and the dual-process model. In the second contribution, various LP-based reasoning features are applied to model these identified morality viewpoints, via classic moral examples taken off-the-shelf from the literature. For this purpose, our QUALM system, which features a combination of LP abduction, updating, and counterfactuals, supported by LP tabling mechanisms, are mainly employed. The applications are also supported by other existing LP-based systems, featuring preference handling and probabilistic reasoning, which complement QUALM in addressing the morality viewpoints in question.

A Tool for Probabilistic Reasoning Based on Logic Programming and First-Order Theories Under Stable Model Semantics

Abstract: This System Description paper describes the software framework PrASP (“Probabilistic Answer Set Programming”) PrASP is both an uncertainty reasoning and machine learning software and a probabilistic logic programming language based on Answer Set Programming (ASP) Besides serving as a research software platform for non-monotonic (inductive) probabilistic logic programming, our framework mainly targets applications in the area of uncertainty stream reasoning PrASP programs can consist of ASP (AnsProlog) as well as First-Order Logic formulas (with stable model semantics), annotated with conditional or unconditional probabilities or probability intervals A number of alternative inference algorithms allow to attune the system to different task characteristics (eg, whether or not independence assumptions can be made)

Algorithmic Principles Of Mathematical Programming

Abstract: algorithmic principles of mathematical programming is available in our digital library an online access to it is set as public so you can get it instantly. Our book servers hosts in multiple locations, allowing you to get the most less latency time to download any of our books like this one. Merely said, the algorithmic principles of mathematical programming is universally compatible with any devices to read.

Design patterns for multi-agent programming

Abstract: Various agent-based programming languages and frameworks have been proposed to support the development of autonomous agents and multi-agent systems. They have provided a valuable contribution to the identification and operationalisation of agent concepts and abstractions by proposing specific programming constructs. Unfortunately, these contributions have not yet been widely adopted by industry. In this paper, we follow the argument that multi-agent programming technology can find its way to industry by providing a methodology that guides the development of autonomous agents and multi-agent systems in standard programming technology. The proposed methodology explains how some characteristic concepts and abstractions related to autonomous agents and multi-agent systems can be implemented in object-oriented technology. This is done by initiating a Java library of object-oriented design patterns for some characteristic but established programming constructs that have been developed in some agent-based programming languages.

A small embedding of logic programming with a simple complete search

Abstract: We present a straightforward, call-by-value embedding of a small logic programming language with a simple complete search. We construct the entire language in 54 lines of Racket---half of which implement unification. We then layer over it, in 43 lines, a reconstruction of an existing logic programming language, miniKanren, and attest to our implementation's pedagogical value. Evidence suggests our combination of expressiveness, concision, and elegance is compelling: since microKanren's release, it has spawned over 50 embeddings in over two dozen host languages, including Go, Haskell, Prolog and Smalltalk.

A Calculus for Variational Programming.

Abstract: Variation is ubiquitous in software. Many applications can benefit from making this variation explicit, then manipulating and computing with it directly---a technique we call "variational programming". This idea has been independently discovered in several application domains, such as efficiently analyzing and verifying software product lines, combining bounded and symbolic model-checking, and computing with alternative privacy profiles. Although these domains share similar core problems, and there are also many similarities in the solutions, there is no dedicated programming language support for variational programming. This makes the various implementations tedious, prone to errors, hard to maintain and reuse, and difficult to compare. In this paper we present a calculus that forms the basis of a programming language with explicit support for representing, manipulating, and computing with variation in programs and data. We illustrate how such a language can simplify the implementation of variational programming tasks. We present the syntax and semantics of the core calculus, a sound type system, and a type inference algorithm that produces principal types.