Functional Programming Concepts Research Articles

Memory-Aware Functional IR for Higher-Level Synthesis of Accelerators

Specialized accelerators deliver orders of a magnitude of higher performance than general-purpose processors. The ever-changing nature of modern workloads is pushing the adoption of Field Programmable Gate Arrays (FPGAs) as the substrate of choice. However, FPGAs are hard to program directly using Hardware Description Languages (HDLs). Even modern high-level HDLs, e.g., Spatial and Chisel, still require hardware expertise. This article adopts functional programming concepts to provide a hardware-agnostic higher-level programming abstraction. During synthesis, these abstractions are mechanically lowered into a functional Intermediate Representation (IR) that defines a specific hardware design point. This novel IR expresses different forms of parallelism and standard memory features such as asynchronous off-chip memories or synchronous on-chip buffers. Exposing such features at the IR level is essential for achieving high performance. The viability of this approach is demonstrated on two stencil computations and by exploring the optimization space of matrix-matrix multiplication. Starting from a high-level representation for these algorithms, our compiler produces low-level VHSIC Hardware Description Language (VHDL) code automatically. Several design points are evaluated on an Intel Arria 10 FPGA, demonstrating the ability of the IR to exploit different hardware features. This article also shows that the designs produced are competitive with highly tuned OpenCL implementations and outperform hardware-agnostic OpenCL code.

Implementing a Library for Probabilistic Programming Using Non-strict Non-determinism

AbstractThis paper presentsPFLP, a library for probabilistic programming in the functional logic programming language Curry. It demonstrates how the concepts of a functional logic programming language support the implementation of a library for probabilistic programming. In fact, the paradigms of functional logic and probabilistic programming are closely connected. That is, language characteristics from one area exist in the other and vice versa. For example, the concepts of non-deterministic choice and call-time choice as known from functional logic programming are related to and coincide with stochastic memoization and probabilistic choice in probabilistic programming, respectively. We will further see that an implementation based on the concepts of functional logic programming can have benefits with respect to performance compared to a standard list-based implementation and can even compete with full-blown probabilistic programming languages, which we illustrate by several benchmarks.

Teaching how to program using automated assessment and functional glossy games (experience report)

Our department has long been an advocate of the functional-first school of programming and has been teaching Haskell as a first language in introductory programming course units for 20 years. Although the functional style is largely beneficial, it needs to be taught in an enthusiastic and captivating way to fight the unusually high computer science drop-out rates and appeal to a heterogeneous population of students. This paper reports our experience of restructuring, over the last 5 years, an introductory laboratory course unit that trains hands-on functional programming concepts and good software development practices. We have been using game programming to keep students motivated, and following a methodology that hinges on test-driven development and continuous bidirectional feedback . We summarise successes and missteps, and how we have learned from our experience to arrive at a model for comprehensive and interactive functional game programming assignments and a general functionally-powered automated assessment platform , that together provide a more engaging learning experience for students. In our experience, we have been able to teach increasingly more advanced functional programming concepts while improving student engagement.

Teaching Functional Patterns through Robotic Applications

We present our approach to teaching functional programming to First Year Computer Science students at Middlesex University through projects in robotics. A holistic approach is taken to the curriculum, emphasising the connections between different subject areas. A key part of the students' learning is through practical projects that draw upon and integrate the taught material. To support these, we developed the Middlesex Robotic plaTfOrm (MIRTO), an open-source platform built using Raspberry Pi, Arduino, HUB-ee wheels and running Racket (a LISP dialect). In this paper we present the motivations for our choices and explain how a number of concepts of functional programming may be employed when programming robotic applications. We present some students' work with robotics projects: we consider the use of robotics projects to have been a success, both for their value in reinforcing students' understanding of programming concepts and for their value in motivating the students.

Why Scala matters

Scale is a blend of object-oriented and functional programming concepts in a statically typed language. The combination of both styles in Scala makes it possible to extend into a new domain-specifi...

IJARCCE - Computer and Communication Engineering

Towers of Hanoi is a standard planning problem in the field of computer science. It has applications in various fields of engineering. Solution to Towers of Hanoi is generally provided by method of recursion. Recursion is a functional programming concept widely used to solve variety of problems. Recursion has been providing solution to this problem most efficiently; hence other methods of solving have not been explored. In this paper we study artificial intelligence method of solving the problem. Artificial intelligence is a field of study which aims at creating intelligence in computer systems. Genetic algorithm is a well-known algorithm for optimization used in artificial intelligence. In this paper we have studied a method of solving Towers of Hanoi using genetic algorithm. Parallelism is achieved through OpenMp.We propose a comparative study of both Genetic algorithm and Recursive algorithm in solving Towers of Hanoi puzzle. Results for the same are presented. I. INTRODUCTION Artificial intelligence is an emerging field of study. If implemented efficiently, it is a field with potential to change the world. It is a dream of every engineer to build system which is intelligent. In this paper we study a method based on artificial intelligence in solving Towers of Hanoi (1). The reason for study of this method is because it is a method which solves the problem without being explicitly programmed. Towers of Hanoi are a standard recursive problem in the field of computer science. It is well known mathematical puzzle invented by Edouard Lucas (hence also known as Lucas' Tower). The problem basically consists of three rods A, B and C. A known number of disks of unequal sizes are placed in one of the three rod (consider rod A). The problem is complete when all the disks are moved from one rod (rod A) to another rod (rod B) by making use of an auxiliary rod (rod B).The constraints for transfer of disks has following constraints.  Only one disk can be moved at a time.

A Critical Evaluation on Programming Paradigms to Achieve Optimal Resource Utilization of Mobile Softwares in Mobile Devices

This paper evaluates the features of mainstream programming paradigms. Imperative, object oriented programming and functional programming concepts are considered here. This is an effort to identify the programming paradigms which consume less resource from mobile devices. Designers usually depend on the programming languages, language oriented programming design is in current practice. Choosing appropriate programming paradigms during the mobile application design is not in practice now; Failure to use the best approaches for mobile computing from programming paradigms will cause mobile applications to consume more mobile resources. Imperative paradigm concepts such as inheritance, creating redundant objects, unnecessary constructors, recursion, strings concatenation, thread synchronization, using global variables and abstract methods results in redundancy, memory leaks, stack overflow, low execution speed and consumes more memory. These features are relatively not suitable for mobile software development. Functional paradigm concepts such as higher order functions, tail recursion, lazy evaluation, referential transparency, parametric polymorphism, and list comprehension principles are suitable for mobile software development as they consume less memory and or use less processing power. Using appropriate paradigms will optimize the resource utilisation of mobile applications in mobile devices.

Formalization and composition of languages for the modeling of fire safety systems

Modeling complex systems, such as the ones found in the certification of fire protection systems, generally requires the intervention of many specialists, each one using its own formalisms, concepts and tools. To model such systems, many specific languages are required and to be integrated they should be formally described. In this proposal, we suggest to use functional programming concepts to formalize and integrate the languages involved in the field of fire safety systems. Formalization is done by specifying constructor functions and integration by the way of generic/higher-order functions.

Visual Lisp/CLOS programming in OpenMusic

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.

Confessions of a used programming language salesman

For many years I had been fruitlessly trying to sell functional programming and Haskell to solve real world problems such as scripting and data-intensive three-tier distributed web applications. The lack of widespread adoption of Haskell is a real pity. Functional programming concepts are key to curing many of the headaches that plague the majority of programmers, who today are forced to use imperative languages. If the mountain won't come to Mohammed, Mohammed must go to the mountain, and so I left academia to join industry. Instead of trying to convince imperative programmers to forget everything they already know and learn something completely new, I decided to infuse existing imperative object-oriented programming languages with functional programming features. As a result, functional programming has finally reached the masses, except that it is called Visual Basic 9 instead of Haskell 98.

Lazy functional programming in Java

In this paper, we show how lazy functional programming techniques can be used within the Java programming language. We provide Java implementations of classic examples of lazy lists, such as the Sieve of Eratosthenes, the Eight Queens Problem, and natural-language parsing. We discuss how well these implementations succeed, compared to their original counterparts. We also point out the potential synergy between adding lazy techniques to Java, and adding generic types. The examples we provide would be suitable for teaching functional programming concepts in the context of a Java-based syllabus.

Software is discrete mathematics

A three-year study collected information bearing on the question of whether studying mathematics improves programming skills. An analysis of the data revealed significant differences in the programming effectiveness of two populations of students: (1) those who studied discrete mathematics through examples focused on reasoning about software and (2) those who studied the same mathematical topics illustrated with more traditional examples. Functional programming played a central role in the study because it provides a straightforward framework for the presentation of concepts such as predicate logic and proof by induction. Such topics can be covered in depth, staying almost entirely within the context of reasoning about software. The intricate complexities in logic that mutable variables carry with them need not arise, early on, to confuse novices struggling to understand new ideas. In addition, because functional languages provide useful and compact ways to express mathematical concepts, and because the choice of notation in mathematics courses is often at the discretion of the instructor (in contrast to the notational restrictions often fiercely guarded by the faculty in programming courses), discrete mathematics courses, as they are found in most computer science programs, provide an easy opportunity to enhance the education of students by exposing them to functional programming concepts.

Functional programming concepts and straight-line programs in computer algebra

In this paper we present MILONGA, a language based on functional programming concepts, which was designed for the implementation of a new generation of nonterm-rewriting elimination algorithms for multivariate polynomial solving [J. Pure Appl. Alg. 124 (1998) 101–146; J. Pure Appl. Alg. 117/118 (1997) 277–317; Appl. Alg. Eng. Commun. Comput. 11 (4) (2001) 239–296; J. Complex. 17 (1) (2001) 154–211]. These new algorithms profit from an alternative representation of multivariate polynomials by means of straight-line programs [Algebraic complexity theory, in: Handbook of Theoretical Computer Science, Elsevier, Amsterdam, 1990, pp. 634–671 (Chapter 11); Algebraic complexity theory, in: Grundlehren der mathematischen Wissenschaften, Vol. 315, Springer, Berlin, 1997] allowing an exponential improvement of theoretical complexity—with respect to computing time and memory space—upon traditional, term-rewriting procedures. There is a strong analogy between the way how these algorithms employ straight-line programs and the way how functional programming languages treat functions as first-class citizens. Taking advantage of this circumstance, the MILONGA language enables us to analyze the relevance of the functional programming paradigm for the particular kind of task of polynomial equation solving. The paper contains an exhaustive do-it-yourself description of the programming philosophy of MILONGA, of the development of its compiler, of the operational semantics of its run-time system and of the implementation of a couple of fundamental computer algebra procedures in this language. The practical efficiency of this philosophy and implementation is outlined by comparative benchmarking on significant test examples.

Towards the uniform implementation of declarative languages

Current implementation techniques for functional languages differ considerably from those for logic languages. This complicates the development of flexible and efficient abstract machines that can be used for the compilation of declarative languages combining concepts of functional and logic programming. We propose an abstract machine, called the JUMP-machine, which systematically integrates the operational concepts needed to implement the functional and logic programming paradigm. The use of a tagless representation for heap objects, which originates from the Spineless Tagless G-machine, supports the integration of different concepts. In this paper, we provide a functional logic kernel language and show how to translate it into the abstract machine language of the JUMP-machine. Furthermore, we define the operational semantics of the machine language formally and discuss the mapping of the abstract machine to concrete machine architectures. We tested the approach by writing a compiler for the functional logic language GTML. The obtained performance results indicate that the proposed method allows to implement functional logic languages efficiently.

An Introduction to S and S-Plus

From the Publisher: Accessing the power of S. . .designed to make the language of choice for high-end research statisticians more accessible, this book demonstrates how to get the most out of the unique power of S to display, manipulate, analyze, and graph data. An Introduction to S and S-PLUS presents ideas and methods in a straightforward manner to extend computerized research possibilities for anyone involved in data management, manipulation and presentation of statistical computing, statistical modeling, or graphics. To encourage effective self-study and hands-on experimentation, the author accompanies his presentation of every concept with an example, either using data sets that are distributed with S or easily created from them. It should not be necessary to enter any data to recreate the examples in the book. Throughout, the focus is on the unique features of S (and its commercial version, S-PLUS) that do not have exact parallels in other languages. Among the topics examined are functional programming concepts, production of custom graphics, and the writing of functions.

A new programming paradigm for engineering design software

Currently available programming and database systems are insufficient for engineering applications. The authors contend that a logical progression from a formal conceptual model of the engineering domain to a computational model will lead to new programming paradigms capable of directly supporting engineering applications in a rigorous, concise manner. A formal domain model devised by the authors, theHybrid Model (HM) of design information, is briefly introduced. It is an extension of axiomatic set theory and is discussed in detail elsewhere. HM forms the basis ofDesigner, a prototype-based object-oriented programming language supporting a signature-based canonical message-passing mechanism and multiple inheritance. Designer is implemented using the Scheme programming language. Because Designer satisfies a formal conceptual model, and because it is based on a formally specified language, its robustness and logical validity are superior to those of other languages not founded on formal principles. Designer combines concepts of functional and object-oriented programming to provide the formal rigor and flexibility to capture the complex and strongly interrelated information that designers use. Examples demonstrate how Designer represents design information. The results of the authors' research indicate that Designer can capture design information (including aspects of functional requirements and design intent) effectively and efficiently.

Machines and models for parallel computing

It is widely believed that superscalar and superpipelined extensions of RISC style architecture will dominate future processor design, and that needs of parallel computing will have little effect on processor architecture. This belief ignores the issues of memory latency and synchronization, and fails to recognize the opportunity to support a general semantic model for parallel computing. Efforts to extend the shared-memory model using standard microprocessors have led to systems that implement no satisfactory model of computing, and present the programmer with a difficult interface on which to build parallel computing applications. A more satisfactory model for parallel computing may be obtained on the basis of functional programming concepts and the principles of modular software construction. We recommend that designs for computers be built on such a general semantic model of parallel computation. Multithreading concepts and dataflow principles can frame the architecture of these new machines.

Functional programming on a dataflow architecture: Applications in real-time image processing

This paper presents a dataflow functional computer (DFFC) developed at the Etablissement Technique Central de l'Armement (ETCA) and dedicated to real-time image processing. Two types of data-driven processing elements, dedicated respectively to low-level and mid-level processings are integrated in a regular 3D array. The design of the DFFC relies on a close integration of the dataflow-architecture principles and the functional programming concept. An image processing algorithm, expressed with a syntax similar to that of functional programming (FP) is first converted into a dataflow graph. The nodes of this graph are real-time operators that can be implemented on the physical processors of the dataflow machine. This dataflow graph is then mapped directly onto the processor array. The programming environment includes a complete compilation stream from the FP specification to hardware implementation, along with a global operator database. Apart from being a research tool for real-time image processing, the DFFC may also be used to perform the automatic synthesis of autonomous vision automata from a high-level functional specification. An experimental system, including 1024 lowlevel custom dataflow processors and 12 T800 transputers, was built and can perform up to 50 billion operations/s. Several image processing algorithms were implemented on this system and run in real-time at digital video speed.

Introducing functional programming in discrete mathematics

Programming assignments in my discrete mathematics course have changed recently due to an influx of non-computer science students with little or no programming experience. Programming problems are now assigned in a simple to learn, easy to write, mathematical-like functional programming language that requires no previous programming experience. In theory, all students begin on the same basis. Exposure to the concepts of functional programming is an essential part of computer science and mathematics curricula. For most students this is the only exposure to functional programming. Functional programming and discrete mathematics are a natural combination. One week of lectures and perhaps a small monetary investment is all that is required. An instructor totally unfamiliar with functional programming can easily learn enough in a week or so to present a simple introduction to the topic. Introducing functional programming concepts in discrete mathematics was very successful. Students found the exposure to functional programming to be an insight they had never experienced before and enthusiastically recommended an introduction to functional programming be a permanent part of the course.

Teaching some modern functional programming concepts

In this paper a new approach to teach functional programming, based on a suitable extension of a Backus' FP-like language is presented. Our approach outperforms some others also discussed in ability concise, but not superficially to cover the whole range from very theoretic issues to very pragmatic ones.