Towards A Generic Computational Intelligence Library: Preventing Insanity

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 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.


 
 
 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.
 
 

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.

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.

Recommendations on the Testing and Use of Pseudo-Random Number Generators Used in Monte Carlo Analysis for Risk Assessment

The relation between logic and functional languages: a survey

It is well known that modern functional programming languages are naturally amenable to parallel programming. Achieving efficient parallelism using functional languages, however, remains difficult. Perhaps the most important reason for this is their lack of support for efficient in-place updates, i.e., mutation, which is important for the implementation of both parallel algorithms and the run-time system services (e.g., schedulers and synchronization primitives) used to execute them. In this paper, we propose techniques for efficient mutation in parallel functional languages. To this end, we couple the memory manager with the thread scheduler to make reading and updating data allocated by nested threads efficient. We describe the key algorithms behind our technique, implement them in the MLton Standard ML compiler, and present an empirical evaluation. Our experiments show that the approach performs well, significantly improving efficiency over existing functional language implementations.

It is well known that modern functional programming languages are naturally amenable to parallel programming. Achieving efficient parallelism using functional languages, however, remains difficult. Perhaps the most important reason for this is their lack of support for efficient in-place updates, i.e., mutation, which is important for the implementation of both parallel algorithms and the run-time system services (e.g., schedulers and synchronization primitives) used to execute them. In this paper, we propose techniques for efficient mutation in parallel functional languages. To this end, we couple the memory manager with the thread scheduler to make reading and updating data allocated by nested threads efficient. We describe the key algorithms behind our technique, implement them in the MLton Standard ML compiler, and present an empirical evaluation. Our experiments show that the approach performs well, significantly improving efficiency over existing functional language implementations.

The correspondence between the triadic sign model proposed by Peirce and the dyadic sign model proposed by Saussure is examined. Traditionally, it has been thought that Peirce's interpretant corresponds to Saussure's signified and Saussure's model lacks Peirce's object. However, our analysis of the two most widely used computer programming paradigms suggests that Peirce's object formally corresponds to Saussure's signified, and that Saussure's sign model is obtained when Peirce's interpretant is located outside of his model in the language system.

Fully peer-to-peer application software promises many benefits over cloud software, in particular, being able to function indefinitely without requiring servers. Research on distributed consistency mechanisms such as CRDTs has laid the foundation for P2P data synchronisation and collaboration. In this paper we report on our experience in taking these technologies beyond research prototypes, and working towards commercial-grade P2P collaboration software. We identify approaches that work well in our experience, such as the functional reactive programming paradigm, and highlight areas in need of further research, such as the reliability of NAT traversal and usability challenges.

In recent years there has been a lot of interest in combining the functional and logic programming paradigms. One of the most semantically elegant of the various proposals is the set abstraction construct. This paper addresses the issues involved in implementing set abstraction. >

A new declarative programming paradigm, constraint functional logic programming (CFLP) is presented, which unifies systematically all features of constraint, functional and logic programming. CFLP extends constraint functional programming (CFP), which supports equation solving over a functional program, to general constraint programming permitting the use of constraints for programming as well as for posing queries. It also generalises constraint logic programming (CLP), by admitting user-defined functions as a purely functional subsystem of a CLP language. This paper presents the motivation for designing CFLP and its semantics. Programming examples are given in the concrete CFLP language Falcon.KeywordsLogic ProgramLogic ProgrammingConstraint ProgrammingConstraint SystemFunctional ProgrammingThese 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.

In this paper we investigate the way in which the Gamma model, proposed by Banâtre and Le Metayer [1], might be supported in a functional language. We discuss the mechanism behind the model and examine the difficulties which arise when implementing Gamma in a functional language. We also explore its applicability as a programming paradigm by developing a library of higher order functions which can be used to facilitate the programming process.