PushPin

In this chapter, we present the main properties of functional programming. In functional programming, computation proceeds by rewriting functions and not by modifying the state. The fundamental characteristic of the languages in this paradigm, at least in their “pure” form, is precisely that of not possessing the concept of memory (and therefore side effect). Once an environment is fixed, an expression always denotes the same value. We will discuss the pure paradigm in the first sections, explaining the fundamental aspects. Functional programming languages, however, merge these “pure” ingredients in a context that adds many other mechanisms; we will review them before touching upon the SECD machine, an abstract machine for higher-order functional languages which constitutes the prototype of many real implementations. We will, at this point, be in a position to discuss the reasons why the functional programming paradigm is interesting with respect to ordinary imperative languages. The chapter concludes with a more theoretical section which provides a succinct introduction to the lambda-calculus, a formal system for computability which inspires all functional languages and which has been a constant model for the design of programming languages.KeywordsNormal FormRecursive FunctionFunctional ProgrammingAbstract MachineFunctional LanguageThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

This paper proposes a library for computational intelligence using functional programming to address the complexities in algorithm implementation and highlighting specific concerns that are often ignored in the algorithm descriptions. Useful abstractions, common in the paradigm of functional programming, are used to make implementation specifics of algorithms part of the algorithm definition, resulting in the tracking of these effects, together with the control of the effects. Effects, requiring management within an algorithm, include the use of pseudo-random number generators, writing data to files or the console, or providing the control parameter configuration of the algorithm in an experiment. By defining the units of work for an algorithm in a general and generic form, composition of these different algorithmic units is possible, thereby creating larger, more complex computational units. The software library providing such reusable, peer-reviewed compos able computational unit, is called CIlib.

This paper explores the theory and implementation of ray tracing in OCaml. We discuss the mathematical concepts and algorithms that drive the rendering process, followed by implementation using OCaml’s functional programming paradigm. Our analysis compares the merits and challenges of functional versus object-oriented (OO) approaches, highlighting the advantages of code clarity, static type safety, and ease of debugging in a functional style. With the development of functional programming module, it has been established that the debugging cost is higher in object oriented module. In this context the functional module can identify the errors at the time of compilation and we establish this fact with the development of code using OCaml. We also address performance considerations related to recursive function calls and state management complexities. Ultimately, we advocate for implementing a basic ray tracer in a functional style, demonstrating that this approach enhances code quality while aligning with the principles of immutability and strong typing.

Objectives: The main objective of this paper is to identify suitable programming concepts from Functional Programming paradigm concerning low resource devices development and eventually contribute an approach for design level optimization. Methods: Experiments have been conducted, CPU time and memory consumptions (Private Bytes) were measured. Findings: The research results indicated that Pattern Matching, Lazy, Curried, Tail Recursion, Functional Composition, Referential Transparency and Higher Order Functions with functions as parameters concepts consumed less CPU and memory resources compared to their alternative concepts. This paper suggests that the above mentioned concepts can be applied by any software engineering practitioners in designing resource efficient constructs for software applications. Applications: Using these guidelines substantial performance growth can be formed and at the same time, performance degradation issues can be easily avoided. Eventually, this paper contributes a way to optimize the Functional Programming design at design level.

Functional Reactive Programming (FRP) is an approach to reactive programming where systems are structured as networks of functions operating on signals. FRP is based on the synchronous data-flow paradigm and supports both continuous-time and discrete-time signals (hybrid systems). What sets FRP apart from most other languages for similar applications is its support for systems with dynamic structure and for higher-order reactive constructs.Statically guaranteeing correctness properties of programs is an attractive proposition. This is true in particular for typical application domains for reactive programming such as embedded systems. To that end, many existing reactive languages have type systems or other static checks that guarantee domain-specific properties, such as feedback loops always being well-formed. However, they are limited in their capabilities to support dynamism and higher-order data-flow compared with FRP. Thus, the onus of ensuring such properties of FRP programs has so far been on the programmer as established static techniques do not suffice.In this paper, we show how dependent types allow this concern to be addressed. We present an implementation of FRP embedded in the dependently-typed language Agda, leveraging the type system of the host language to craft a domain-specific (dependent) type system for FRP. The implementation constitutes a discrete, operational semantics of FRP, and as it passes the Agda type, coverage, and termination checks, we know the operational semantics is total, which means our type system is safe.

This volume contains the papers presented at the 7th ACM-SIGPLAN International Symposium on Principles and Practice of Declarative Programming (PPDP 2005), held in Lisboa, Portugal, July 11-13, 2005. This symposium is the seventh in this series of international meetings on declarative programming. The previous meetings were held in Verona, Italy in 2004, Uppsala, Sweden in 2003, Pittsburgh, USA in 2002, Firenze, Italy in 2001, Montreal, Canada in 2000, and Paris, France in 1999.PPDP 2005 aims to provide a forum that brings together those in the declarative programming communities, including those working in the logic, constraint, and functional programming paradigms. The goal is to stimulate research in the use of logical formalisms and methods for specifying, performing, and analyzing computations, and to stimulate cross-fertilization by including work from one community that could be of particular interest and relevance to the others. Topics of more specific interest include enhancements to such formalisms with mechanisms for mobility, modularity, concurrency, object-orientation, and static analysis, as well as the fuller exploitation of the programming-as-proof-search framework through new designs and improved implementation methods. At the level of methodology, the use of logic-based principles in the design of tools for program development, analysis, and verification relative to all declarative paradigms is of interest.A total of 45 submissions were received in response to the call for papers. Each paper was reviewed by three referees and 20 papers were accepted for publication in these proceedings. In addition to the accepted papers, the scientific program included an invited talk by Manuel Hermenegildo (Technical University of Madrid and University of New Mexico), as well as two invited talks joint with the 32nd International Colloquium on Automata, Languages, and Programming (ICALP 2005), given by Giuseppe Castagna (ENS Paris) and John Mitchell (Stanford University).

In this paper, we discuss the cost of functional classes design style. Functional classes merge both object-oriented and functional programming paradigms; a functional class is a class without variables. Because of this, the methods in functional classes are true functions. Functional classes design style aims at improving reliability and program correctness. However, resulting program code is not optimal when considering the performance. As the main contribution, we analyze here the performance of functional classes in Java. We study especially the cost of recursive method calls. As the case study, we analyze an implementation of the cartesian product operation in a lightweight data mediator. The analysis confirms that functional classes design style leads to implementations that make poor use of HotSpot. However, the analysis also indicates how to restructure a functional class to improve the performance.


 
 
 Several techniques and criteria are available to help conducting testing activity. The choice for one of them depends on different aspects, such as the time restrictions, ef- fectiveness of the testing criteria or the features of the program under test. In this context, the programming paradigm might influence in the testing activity cost. This paper presents the results of an experimental study to characterize and evaluate the cost and strength of structural and functional testing criteria, comparing object-oriented and procedural programming paradigms. A set of 32 programs from the data structure do- main was considered in this study. The main goals in the execution of this research were: i) to obtain initial results about the investigated questions; ii) to generate artifacts which can be used as basis to define and conduct further experimental studies; iii) to support training and teaching of software testing activity.
 
 

Functional reactive programming (FRP) is a declarative programming paradigm where the basic notions are continuous, time-varying behaviors and discrete, event-based reactivity. FRP has been used successfully in many reactive programming domains such as animation, robotics, and graphical user interfaces. The success of FRP in these domains encourages us to consider its use in real-time applications, where it is crucial that the cost of running a program be bounded and known before run-time. But previous work on the semantics and implementation of FRP was not explicitly concerned about the issues of cost. In fact, the resource consumption of FRP programs in the current implementation is often hard to predict. As a first step towards addressing these concerns, this paper presents real-time FRP (RT-FRP), a statically-typed language where the time and space cost of each execution step for a given program is statically bounded. To take advantage of existing work on languages with bounded resources, we split RT-FRP into two parts: a reactive part that captures the essential ingredients of FRP programs, and a base language part that can be instantiated to any generic programming language that has been shown to be terminating and resource-bounded. This allows us to focus on the issues specific to RT-FRP, namely, two forms of recursion. After presenting the operational explanation of what can go wrong due to the presence of recursion, we show how the typed version of the language is terminating and resource-bounded. Most of our FRP programs are expressible directly in RT. The rest are expressible via a simple mechanism that integrates RT-FRP with the base language.

Functional reactive programming (FRP) is a paradigm for programming with signals and events, allowing the user to describe reactive programs on a high level of abstraction. For this to make sense, an FRP language must ensure that all programs are causal, and can be implemented without introducing space leaks and time leaks. To this end, some FRP languages do not give direct access to signals, but just to signal functions. Recently, modal types have been suggested as an alternative approach to ensuring causality in FRP languages in the synchronous case, giving direct access to the signal and event abstractions. This paper presents Simply RaTT , a new modal calculus for reactive programming. Unlike prior calculi, Simply RaTT uses a Fitch-style approach to modal types, which simplifies the type system and makes programs more concise. Echoing a previous result by Krishnaswami for a different language, we devise an operational semantics that safely executes Simply RaTT programs without space leaks. We also identify a source of time leaks present in other modal FRP languages: The unfolding of fixed points in delayed computations. The Fitch-style presentation allows an easy way to rules out these leaks, which appears not to be possible in the more traditional dual context approach.

The relation between logic and functional languages: a survey

Graphical user interfaces (GUIs) mediate many of our interactions with computers. Functional Reactive Programming (FRP) is a promising approach to GUI design, providing high-level, declarative, compositional abstractions to describe user interactions and time-dependent computations. We present Elm, a practical FRP language focused on easy creation of responsive GUIs. Elm has two major features: simple declarative support for Asynchronous FRP ; and purely functional graphical layout. Asynchronous FRP allows the programmer to specify when the global ordering of event processing can be violated, and thus enables efficient concurrent execution of FRP programs; long-running computation can be executed asynchronously and not adversely affect the responsiveness of the user interface. Layout in Elm is achieved using a purely functional declarative framework that makes it simple to create and combine text, images, and video into rich multimedia displays. Together, Elm's two major features simplify the complicated task of creating responsive and usable GUIs.

Functional Reactive Programming (FRP) is an approach to the development of reactive systems which provides a pure functional interface, but which may be implemented as an abstraction of an imperative event-driven layer. FRP systems typically provide a model of behaviours (total time-indexed values, implemented as pull systems) and event sources (partial time-indexed values, implemented as push systems). In this paper, we investigate a type system for event-driven FRP programs which provide liveness guarantees, that is every input event is guaranteed to generate an output event. We show that FRP can be implemented on top of a model of sets and relations, and that the isomorphism between event sources and behaviours corresponds to the isomorphism between relations and set-valued functions. We then implement sets and relations using a model of continuations using the usual double-negation CPS transform. The implementation of behaviours as pull systems based on futures, and of event sources as push systems based on the observer pattern, thus arises from first principles. We also discuss a Java implementation of the FRP model.

Functional Reactive Programming (FRP) models reactive systems with events and signals, which have previously been observed to correspond to the "eventually" and "always" modalities of linear temporal logic (LTL). In this paper, we define a constructive variant of LTL with least fixed point and greatest fixed point operators in the spirit of the modal mu-calculus, and give it a proofs-as-programs interpretation as a foundational calculus for reactive programs. Previous work emphasized the propositions-as-types part of the correspondence between LTL and FRP; here we emphasize the proofs-as-programs part by employing structural proof theory. We show that the type system is expressive enough to enforce liveness properties such as the fairness of schedulers and the eventual delivery of results. We illustrate programming in this calculus using (co)iteration operators. We prove type preservation of our operational semantics, which guarantees that our programs are causal. We give also a proof of strong normalization which provides justification that our programs are productive and that they satisfy liveness properties derived from their types.

FRP (functional reactive programming) is a domain- specific sub-language embedded in Haskell. FRP is developed based on the arrow types and suitable for programming reactive systems such as robot systems. An essential higher-order type, namely signal, provides higher levels of abstractions of reactive systems. However, FRP can not be directly applicable to most robot systems since it is implemented on top of a heavy language Haskell. To overcome this limitation, RT-FRP (real-time functional reactive programming) was proposed, but any practical implementation of RT-FRP has not been proposed currently. In this paper, RT-FRP is implemented as a form of C translator. The proposed translator converts RT-FRP programs into C programs. To measure the effectiveness of the RT-FRP translator, some robot control programs are developed, translated, and loaded on top of LEGO MindStorm. According to the experimental result, the reactive logic can be coded more concisely using RT-FRP than C although the size of the binary code is somewhat increased.