Functional Programming

One-to-one dependencies in database design

by Peretz Shoval

Author: Peretz Shoval
Journal: IIEEE Transactions on Knowledge & Data Engineering (1991), Vol. 3, 371-379.

The types of dependencies between objects in some reality determine to a large extent the structure of its database... more The types of dependencies between objects in some reality determine to a large extent the structure of its database schema. While 1:n (or n:l) and m:n dependencies received extensive treatment in various models and methods for database design, 1:l dependencies received arbitrary treatment only. We focus on the 1:l dependency type and show its significance in database design. Various situations involving 1:l dependencies are analyzed and classified, and proper treatment of the dependency in those situations is suggested. These dependencies are treated at both the conceptual and the logical design levels. Decision rules are provided for the conversion of 1:l dependencies into 1:n or n:l dependencies. These are implemented within the system ADDS for automated database design.

Haskell#: Parallel Programming Made Simple and Efficient

by Francisco Carvalho-Junior

Journal of Universal Computer Science
Volume 9, Issue 8

This paper presents the final result of the designing of a new specification for the Haskell# Language, including new... more This paper presents the final result of the designing of a new specification for the Haskell# Language, including new features to increase its expressiveness, but without losing either efficiency or obedience to its original premisses.

Parallelizing MCP-Haskell for Evaluating Haskel# Parallel Programming Environment

by Francisco Carvalho-Junior

Proceedings of the 2001 Brazilian Symposium on Computer Architectures and High Performance Computing (SBAC-PAD'2001)

In this paper, we present the parallelization of a sequential functional implementation of a Monte Carlo Transport... more In this paper, we present the parallelization of a sequential functional implementation of a Monte Carlo Transport Problem, called MCP- Haskell[Hammes et al., 1995], using Haskell # . This experiment gave us important feedback for evaluating Haskell # features, helping us to answer some questions, like how expressive is Haskell # for representing known parallel computational patterns, how easy it is to build large scale parallel programs in an elegant and concise way, and how efficient are Haskell # programs. Based on our conclusions, we suggest new features to be incorporated in Haskell # to improve its expressiveness and performance. We also present the performance figures for the MCP-Haskell # benchmark.

Coordinating Functional Processes with Haskell#

by Francisco Carvalho-Junior

Proceedings of the 2002 ACM symposium on Applied computing (SAC'2002)
Special Track on Coordination Models and Languages

This paper presents Haskell#, a parallel functional language based on coordination. Haskell# supports lazy stream... more This paper presents Haskell#, a parallel functional language based on coordination. Haskell# supports lazy stream communication and facilities, at coordination level, to the specification of data parallel programs. Haskell# supports a clean and complete, semantic and syntactic, separation between coordination and computation levels of programming, with several benefits to parallel program engineering. The implementation of some well-known applications in Haskell# is presented, demonstrating its expressiveness, allowing for elegant, simple, and concise specification of any static pattern of parallel, concurrent or distributed computation.

Translating Haskell# Programs into Petri Nets

by Francisco Carvalho-Junior

Lecture Notes in Computer Science
Volume 2565, pages 635-649
DOI: 10.1007/3-540-36569-9_43

Abstract Haskell# is a concurrent programming environment aimed at parallel distributed architectures. Haskell#... more Abstract Haskell# is a concurrent programming environment aimed at parallel distributed architectures. Haskell# programs may be automatically translated to Petri nets, an important formalism for analysis of properties of concurrent and non-determinisc systems. This paper motivates and formalizes the translation of Haskell# programs into Petri nets, providing some examples of their usage.

On the implementation of SPMD applications using Haskell#

by Francisco Carvalho-Junior

Proceedings of the 15th Brazilian Symposium on Computer Architecture and High Performance Computing (SBAC-PAD'2003)

Commodities-built clusters, a low cost alternative for distributed parallel processing, brought high-performance... more Commodities-built clusters, a low cost alternative for distributed parallel processing, brought high-performance computing to a wide range of users. Most of them are interested in parallelising scientific applications. Message passing parallel programming using lower level mechanisms, such as MPI and PVM libraries, has become popular, because these tools are free, easy to obtain, and efficient. However, for large-scale applications, parallel software engineering using low level tools is a very hard task, due to its poor abstraction and modularity. This makes difficult the widespread use of cluster computing, by mathematicians, biologists, engineers, physicists, et al. Haskell# is an attempt to bring together higher-level parallel programming and cluster-based architectures, without sacrificing speedup and scalability. This paper compares speedup, scalability, and modularity of Haskell# and MPI implementations of some representative NAS benchmarks (EP, IS and CG).

An Action Semantics for STG

by Francisco Carvalho-Junior

Brics Notes Series,
Volume 6, pp. 98-117
2000

STG (Shared Term Graph) is a very simple higher order non-strict pure functional language, primarily designed to be... more STG (Shared Term Graph) is a very simple higher order non-strict pure functional language, primarily designed to be the "abstract machine code" of STG-machine (Spineless Tagless G-Machine), an abstract machine designed to support implementation of lazy functional languages, like Haskell, on stock hardware. GHC and Haskell/GammaCMC are compilers for Haskell that use STG as intermediate code. This paper gives an action semantics for STG, trying to capture its essential characteristics, like lazy evaluation, higher order functions, pattern matching by case expressions and support for algebraic values.

Topological Skeletons in Haskell#

by Francisco Carvalho-Junior

Proceedings of 2003 International Parallel and Distributed Processing Symposium (IPDPS'2003)

Skeletons is a powerful concept to describe patterns of concurrency in programming, abstracting from implementation.... more Skeletons is a powerful concept to describe patterns of concurrency in programming, abstracting from implementation. Haskell# is a coordination based distributed extension of Haskell. In this paper, it is shown how skeletons can be introduced into Haskell# at configuration level, by extending its notion of hierarchical composition of programs with process templates. The approach described herein is general enough to be applied to configuration languages in general. Its expressiveness, simplicity and elegance are demonstrated by examples, which also show its impact in Haskell# programming practice and performance.

Uniform Memory and Serialization for Lambda Calculus

by Anton Salikhmetov

Constraint Application With Higher-Order Programming for Modeling Music Theories

by Torsten Anders

Anders, T., E. Miranda (2010). Constraint Application with Higher-Order Programming for Modeling Music Theories. Computer Music Journal. 34(2).

This paper studies how compositional rules (constraints) are applied to the score when modelling composition or music... more This paper studies how compositional rules (constraints) are applied to the score when modelling composition or music theory with constraint programming. Our overall objective is to produce a highly generic system, where users can model a wide range of theories, including theories of rhythm, harmony, melody, counterpoint and form. Existing systems provide mechanisms that are convenient for specific cases, but lack generality and cannot be extended by users. For example, constraining notes from different voices in a polyphonic setting (e.g., with harmonic constraints) is inconvenient or even impossible in most systems.

We propose an approach which combines convenience with full user control by using higher-order constraint applicators. A constraint is a first-class function, while a constraint applicator is a higher-order function that traverses the score in order to apply a given constraint to variable sets. This text presents constraint applicators suitable for a many musical CSPs, and reproduces important mechanisms of existing systems. Most importantly, users can define their own constraint applicators with this approach.

Visual Lisp/CLOS Programming in OpenMusic

by Jean Bresson

Jean Bresson, Carlos Agon, Gérard Assayag. Higher-Order and Symbolic Computation, 22(1), 2009.

OpenMusic (OM) is a visual programming language developed on top of Common Lisp and CLOS, in which most of the... more OpenMusic (OM) is a visual programming language developed on top of Common Lisp and CLOS, in which most of the functional and object-oriented programming concepts can be implemented and carried out graphically. Although this visual language was designed for musical applications, the focus in this paper is to describe and study OM as a complete general-purpose programming environment.

(Un-)Building Social Systems. The Concrete Foundations of Society

by Michael Guggenheim

Chapter for book: Ignacio Farias & José Ossandon (ed.) Comunicaciones, semánticas y redes. Usos y desviaciones de la sociología de Niklas Luhmann. México: Universidad Iberoamericana, 2011, 245-277

Designing a theorem prover

by Lawrence Paulson

In: S. Abramsky, D. M. Gabbay and T. S. E. Maibaum (editors), Handbook of Logic in Computer Science, Vol II (Oxford, 1992), 415–475.

This tutorial illustrates some of the issues involved in coding a theorem prover by presenting the design of a simple... more This tutorial illustrates some of the issues involved in coding a theorem prover by presenting the design of a simple automatic prover for first-order logic. The source code is written in standard ML. A first-order logical calculus is also presented and explained.

A Generic Parallel Map: Extending the List Map HOF to Arbitrary Data Structures

by Mohammad Hamdan

Hamdan, M. .(2007). A Generic Parallel Map: Extending the List Map HOF to Arbitrary Data Structures. “Abhath Al-Yarmouk Journal: Basic Sciences and Engineering”. 16(1): 123-134

AHD: The Alternate Hierarchical Decomposition of Nonconvex Polytopes (Generalization of a Convex Polytope Based Spatial Data Model)

by Rizwan Bulbul