Functional Programming Paradigm Research Articles

To Abstract or Not to Abstract? A Comparative Study Evaluating the User Experience of Spreadsheet Programming with Sheet-Defined Functional Abstractions

Spreadsheets are a widespread functional programming paradigm that offer liveness and directness of interaction. However, spreadsheets are notoriously error-prone and difficult to debug. To overcome this limitation and improve the expressive power of spreadsheets, we propose an extension to the spreadsheet paradigm in the form of sheet-defined lambdas – user-defined functions that abstract computations on the sheet. This concept was developed and deployed in our web-based spreadsheet application named Lattice. We evaluate this approach through a user study which compared the user experience of programming in a spreadsheet with and without lambdas, as well as the difference in performance between learner (N = 12) and experienced (N = 12) programmers. The study measured participant task performance (task time, success rate and number of errors) and the quality of their user experience of using Lattice (video recordings of use, interviews and questionnaire responses). Our findings indicate that programming with lambdas is not only more efficient than writing formulas in a conventional way, but also provides a rewarding hedonic experience. However, we found that learners perceived the concept of functional abstractions with lambdas as difficult to comprehend; while experienced programmers noted potential utilitarian advantages that aid in managing the complexity of a spreadsheet program. The results obtained in this work contribute to a better understanding of human-spreadsheet interaction and can inform the future design of user-friendly computational systems.

Pygenomics: manipulating genomic intervals and data files in Python.

We present pygenomics, a Python package for working with genomic intervals and bioinformatic data files. The package implements interval operations, provides both API and CLI, and supports reading and writing data in widely used bioinformatic formats, including BAM, BED, GFF3, and VCF. The source code of pygenomics is provided with in-source documentation and type annotations and adheres to the functional programming paradigm. These features facilitate seamless integration of pygenomics routines into scripts and pipelines. The package is implemented in pure Python using its standard library only and contains the property-based testing framework. Comparison of pygenomics with other Python bioinformatic packages with relation to features and performance is presented. The performance comparison covers operations with genomic intervals, read alignments, and genomic variants and demonstrates that pygenomics is suitable for computationally effective analysis. The source code is available at https://gitlab.com/gtamazian/pygenomics.

Specification transformation method for functional program generation based on partition-recursion refinement rule

Implementations that follow the functional programming paradigm are being used in more and more domains. As functional programming paradigm has mathematical reference transparency, refinement to functional programs contributes to improving the reliability of the transformation process and simplifying the refinement steps. However, it is a challenge to generate functional programs from specifications. Most existing transformation methods refine specifications into abstract algorithm-level programs based on loop invariants rather than functional programs. This paper proposes a novel functional program generation method based on the partition-recursion refinement rule. It establishes a novel program refinement framework based on functional theory for the first time. This is the first study to regard the whole program refinement process as a composition of abstract functions. This paper designs a recurrence-based algorithm design language (Radl+) and implements a software prototype to map Radl+ algorithms into executable Haskell programs. To prove the feasibility and efficiency of this method, this paper transforms the polynomial multiplication problem from a specification into an executable Haskell program. This case shows that compared with existing approaches, the proposed method can simplify the transformation steps and reduce the number of lines of generated code from 38 to 10.

Organization of Calculations and Work with Memory in the Educational Programming Language SYNHRO

The article is devoted to a number of decisions made in the project of the educational programming language Synchro, which is being developed at the Laboratory of Information Systems of the A.P. Ershov IIS SB RAS, designed to familiarize with the basic phenomena of the interaction of processes and control of calculations over shared memory. The focus is on the functional programming paradigm. The language is aimed at schoolchildren of primary and secondary grades, as well as junior students and non-professionals. During training, the experience of operating with toy robots moving on a checkered board is used. The article is of interest to everyone who is interested in the problems of modern computer science, programming and information technology, especially the problems of parallel computing on supercomputers and distributed systems, and in general the use of multiprocessor systems.

Unified type system for the modern general-purpose programing language

The paper presents an overview of the type system, which supports the convergence of procedural, object-oriented, functional, and concurrent programming paradigms relying on static type checking with smart type inference support and the ability to ensure dynamic type safety as well. The key element of the type system is that it is fully based on just 2 basis constants and all other constructions are derived.

Structure verification of deep neural networks at compilation time

This paper presents TensorSafe , a Haskell library that makes possible the definition and structural validation of deep neural network architectures. Nowadays, the development process of deep learning models has been notably simplified due to the availability of sophisticated tools in the industry. However, most of these tools do not provide any security controls at compilation time, making the developers deal with unexpected run-time errors and uncertainties. In particular, validating the structure of deep neural networks at compilation time is a complex subject that involves the mathematical validation of all operations that a deep learning model will perform. Moreover, this structural checking requires an advanced usage of types systems theories to manipulate abstract type definitions capable of modeling neural network constructions. Many different programming techniques were involved in the specification of TensorSafe. Primarily, the application of the functional programming paradigm and the use of type-level programming were of great importance for the development process and to probe the correctness of the neural network models. The experimental evaluation showed that by using TensorSafe it is possible to correctly create well-known deep neural network architectures, such as AlexNet or ResNet50 . • Review state of the art of deep learning DSLs that provide structural controls at compile time. • Extensible Haskell library that is capable of defining non-sequential deep learning architectures. • Interaction with external deep learning frameworks like TensorFlow for JavaScript or Keras for Python.

О функциональном программировании

The article is devoted to the description of the features of functional programming, considered as a methodology for solving new and research problems of applied and system programming. The technique of analysis and comparison of programming paradigms is involved, taking into account the priorities of decision-making in the process of developing programs. The methodology for comparing languages and programming paradigms is based on an informal definition of the term “programming paradigm”, according to which, when comparing paradigms, it is necessary to highlight the distinctive testable features that allow verification. As such signs, it turned out to be useful to use priorities in decision-making at different stages of studying the problem statement, and then developing and debugging a program for solving it. Accounting of priority allows you to predict the complexity of the application of programmable solutions, starting with planning, studying and organizing the development of long-lived programs. The material of the article is somewhat debatable. The article gives a clear formulation of the principles of the functional programming paradigm, which distinguish it from other paradigms. Based on these principles, the derivation of consequences that allow the successful application of functional programming in solving complex problems is carried out, they are concretized to the tasks of organizing parallel computing and improving the performance of programs created within the framework of the functional programming paradigm. The complexity of creating programs for solving new problems is shown on the example of parallel computing and the requirements for a universal multi-paradigm language for parallel computing are described. For functional programming problems, the correctness and completeness of solutions is more important than the efficiency and productivity of the resulting programs. It is this choice of priorities that allows functional programming to be considered as a general technique for preparing prototypes or functional models. We can say that functional programming acts as a design office for production programming.

Reuse estimate and interval prediction using MOGA-NN and RBF-NN in the functional paradigm

• Measuring reusability of functions in functional programming paradigm. • Using Haskell source code metrics to predict reuse estimate of a given function. • Providing interval prediction for reusability rather than point estimates. • Comparing two algorithms used for interval prediction viz. MOGA-NN and RBF-NN. • Concluding that RBF-NN are more useful for interval prediction. Context: Reusability estimation of a software component is beneficial in constructing a library of reusable components. The inherent characteristics of the functional paradigm in principle support reuse better than other paradigms. In this paper, we consider the reusability of functions written in the Haskell programming language, which is a functional programming language. Objective: We aim to develop a framework for measuring the reusability of Haskell functions. Given a function, we build a model that can provide a reuse estimate of that function using source code metrics derived solely from that function. This developed model provides a prediction interval for the reuse estimate, which is more useful than a point estimate because of the confidence associated with the prediction. This paper also compares two algorithms used for interval prediction viz. MOGA-NN and RBF-NN. Method: We have used the Indegree of a function and probabilities derived from the clustering of functions to construct our reuse estimate. We have used a multiobjective genetic algorithm trained neural network (MOGA-NN) and radial basis function neural nets (RBF-NN) combined with the k-nearest neighbor algorithm for making interval predictions. Results: The developed model successfully predicts the reuse estimate of three open-source Haskell packages. Both MOGA-NN and RBF-NN have quite similar performance in terms of Root mean square error values for training and testing data, but RBF-NN dominates in the prediction of the bounds of the reuse estimate. Conclusion: We have shown how source code metrics computed from a Haskell function can be used to predict the reuse estimate of a given function. We also conclude that radial basis function neural networks are more accurate in providing a prediction interval for reuse estimate.

Задачи классификации управления организацией

In the article are considered entities classification issues for the purposes of decision-making in commercial companies and also there are offered algorithm and tools for employees efficiency analysis conducting in the context of clients’ requests processing. The algorithm is based on multiparameter optimization of the initial dataset by fuzzy requirements vectors. As tools there are used Python (TKinter, matplotlib and openpyxl libraries) PHP (data processing and classification via server methods based on Yii 2.0) and also SQL (corporate CRM database queries) languages abilities. Methods, types of requests, processing arrays, program code are presented. Excel and Power BI tools are used to visualize data. They allow you to build different types of charts and graphs. This provides a visual representation of both intermediate and final results. The Power BI tool allows you to receive output in a convenient JSON format. The methodological base, used in this work, is the fuzzy logics terms (membership functions, their arguments and coefficients). Also, there are used functional and object-oriented programming paradigms. As a result of the operation of the algorithm, a set of data is formed for the classification of personnel and decision-making for each of the employees. Thus, the proposed classification allows you to rationally build a personnel policy, optimally distribute the workload, and improve operational management.

DDF Library: Enabling functional programming in a task-based model

In recent years, the areas of High-Performance Computing (HPC) and massive data processing (also know as Big Data) have been in a convergence course, since they tend to be deployed on similar hardware. HPC systems have historically performed well in regular, matrix-based computations; on the other hand, Big Data problems have often excelled in fine-grained, data parallel workloads. While HPC programming is mostly task-based, like COMPSs, popular Big Data environments, like Spark, adopt the functional programming paradigm. A careful analysis shows that there are pros and cons to both approaches, and integrating them may yield interesting results. With that reasoning in mind, we have developed DDF, an API and library for COMPSs that allows developers to use Big Data techniques while using that HPC environment. DDF has a functional-based interface, similar to many Data Science tools, that allows us to use dynamic evaluation to adapt the task execution in run time. It brings some of the qualities of Big Data programming, making it easier for application domain experts to write Data Analysis jobs. In this article we discuss the API and evaluate the impact of the techniques used in its implementation that allow a more efficient COMPSs execution. In addition, we present a performance comparison with Spark in several application patterns. The results show that each technique significantly impacts the performance, allowing COMPSs to outperform Spark in many use cases.

Optimization of machining parameters using artificial Intelligence techniques

In the industrial scenario, there is a requirement for robust tools to estimate the parameters of machining processes precisely. This can be achieved by employing optimization techniques in conjunction with state of the art prediction models to predict the best set of parameters to perform the operation. In this work, the turning operation on titanium alloy is optimized for improved surface roughness while mitigating the effects on the material removal rate by employing non-traditional optimization algorithm. The optimization algorithm demands for a prediction model that establishes an empirical relationship between the parameters in the machining operation and its response variables. The prediction models are employed on turning of Ti-6-Al 4-V Titanium alloy dataset and were contrasted by prediction metrics to determine the best prediction technique. The Artificial Neural Network (ANN) outperformed other prediction models by achieving a mean absolute percentage error of 1.08% as it could learn the non-linear and interaction effects in the data. The algorithms have been implemented in the functional programming paradigm in python (general purpose programming language). The accuracy of prediction model has been improved in contrast to the existing ANN models in the literature by fine tuning the ANN to determine the best architecture and hyper parameters. The ANN was then integrated with the genetic algorithm, a non-traditional meta-heuristic optimization algorithm to arrive at the best set of combination that minimizes the surface roughness while maximizing the material removal rate. A bias factor was introduced to control the optimization between the contradictory objectives. The optimized solutions offered the best combination of operating parameters to achieve the best performance in the given operation.

A parallel implementation strategy for meshless methods based on the functional programming paradigm

In this paper a parallel implementation strategy is presented, for meshless methods, using principles of functional programming and memory polymorphism. The meta-programming presented technique has been developed to guarantee portability of performance in different execution spaces and simplified representation of the mathematical physics model through simple use of declarative programming. To this end, an execution model for meshless methods is defined, under the premise that specializations for execution and memory spaces must take place during compilation time. This means that, the declared model can be simulated in different architectures, without any changes in the implementation. In addition, the included results demonstrate that, it is possible to guarantee portability of performance while reducing the complexity of the model representation. In order to illustrate the defined strategy, an application using the so called meshless local Petrov-Galerkin (MLPG) method is presented. Results are discussed for different boundary value problems, indicating that the presented procedure succeeds in reducing implementation costs to just the time to adapt its efficiency to the execution space of the simulation.

Towards a reactive system for managing big trajectory data

Spatio-temporal events often describe the movements of an object in terms of space, time, and potential other attributes. Significant knowledge can be inferred by analysing them, either individually or atomically in form of trajectories. The trajectories can abstract additional properties and lead to deeper value. Moreover, external contextual information can be attributed to them to change their structure and lead to different perspectives. Because of this potentially valuable knowledge, nowadays indoor and outdoor tracking devices are used everywhere; generating countless events instantaneously. However, the extraction of knowledge from such heterogeneous, massive data is not a trivial task. In other terms, there is a need for a sophisticated system that is efficient in terms of distributed computing, failure handling, responsiveness, and abstraction. To answer this need, our study incorporates a fully fledged, reactive system for big trajectory data management. The system is unique of its kind because it is actor-based and features responsiveness, resiliency, and elasticity. Furthermore, our system is implemented using Scala; hence, we have the expressive power of both the Object-Oriented (OO) and Functional Programming (FP) paradigms. Allowing us to reach a higher level of abstraction to be able to process any trajectory type. The scope of this paper is to detail our system and discuss elasticity, routing strategies, load balancing, and our proper fault-tolerance mechanism. To fulfill this study, we consider the Geolife project’s GPS trajectory dataset.

Understanding the identity function in SML by theory

Motivation Being one of the representative languages in the paradigm of functional programming, Standard ML (SML) offers many advanced features that are rarely seen in imperative programming. One s...

FUNCTIONAL STYLE PROGRAMMING IN JAVASCRIPT: TWO PROBABILITY PROBLEMS

The article contains detailed explanations for two examples of solving simple probability problems with simulations written in JavaScript using functional programming paradigm. Provided material is designed to be used in teaching introductory level of functional programming in upper secondary school.

Special issue on Parallel and distributed computing based on the functional programming paradigm

Special issue on Parallel and distributed computing based on the functional programming paradigm

Programmers do not favor lambda expressions for concurrent object-oriented code

Lambda expressions have long been state-of-the-art in the functional programming paradigm. Especially with regard to the use of higher-order functions, they provide developers with a means of defining predicate or projection functions locally, which greatly increases the comprehensibility of the resulting source code. This benefit has motivated language designers to also incorporate lambda expressions into object-oriented (OO) programming languages. In particular, they are claimed to facilitate concurrent programming. One likely reason for this assumption is their purity: pure lambda expressions are free of side effects, and therefore cannot cause, e.g., race conditions. In this paper, we present the first empirical analysis of whether or not this claim is true for OO projects. For this purpose, we investigated the application of lambda expressions in 2923 open-source projects, implemented in one of the most common OO programming languages: C#, C++, and Java. We present three major findings. First, the majority of lambda expressions are not applied in concurrent code and most concurrent code does not make use of lambda expressions. Second, for all three of the languages, we observed that developers compromise their code by applying a significantly higher number of impure, capturing lambda expressions, which are capable of causing race conditions. Finally, we explored further use cases of lambda expressions and found out that testing, algorithmic implementation, and UI are far more common use-cases for the application of lambda expressions. Our results encourage to investigate in more detail the reasons that hinder programmers to apply lambda expressions in concurrent programming and to support developers, e.g., by providing automatic refactorings.

A Design Level Optimization Approach for Functional Paradigm Software Designs Considering Low Resource Devices Development

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.

A new scheduling algorithm for non-preemptive independent tasks on a multi-processor platform

The abort-and-restart scheme from the Priority-based Functional Reactive Programming (PFRP) paradigm eliminates the priority inversion problem. This paper is similar by solving the priority inversion problem using the task order restrictions sets of relations. One of the core problems in real-time systems is finding a feasible schedule for a task set on a multiprocessor platform. While preemptive scheduling has benefited from a large number of significant results, the non-preemptive case has still room for improvement. Despite the fact that the well-known EDF and LLF scheduling techniques are optimal for preemptive uniprocessor platform there is no known optimal scheduling algorithm for non-preemptive task sets on a multi-processor platform. Our paper continues our previous works [1] and [2] by describing the experimental results together with their findings about our alternate scheduling method to the EDF and LLF techniques. Our algorithm, called A, is able to schedule all considered non-preemptive independent tasks on a multi-processor platform, while EDF and LLF fail to sometimes provide a feasible schedule. The experiments indicate no execution time overhead for the cases where all the scheduling algorithms were able to provide the schedule. However, when EDF and LLF fail to provide a schedule, A gives the schedule with a 60% execution time overhead.

PEDAGOGICAL EDUCATION MOBILITY THROUGH THE EXAMPLE OF PROGRAMMING LANGUAGES TRAINING

The article introduces content of a study program for teaching programming languages to the students of Pedagogical Education with specialty in and Mathematics. When teaching Programming, the task of building up such skills as both cognitive and practical activity of students, their mastering general educational and intellectual abilities becomes vital. Authors of the article explain the necessity to include Python programming language in the discipline Programming. Especially interesting are the components of didactic support of the new course, developed by the authors. The article substantiates methodical sequence Pascal – VBA – Python. By the example of teaching Programming, the article shows mobility of pedagogical education in terms of practice oriented approach to the whole educational process. Further development of programming line in education of future teachers of Informatics and Mathematics implies consideration of paradigm of functional programming, at first within preparation of students’ yearly projects and optional courses. Python language offers ample opportunities and allows implementing not only imperative and object???oriented approaches, but also functional approach, i.e. this language is multi-paradigmatic and has at the same time a low entry threshold. This helps to see a common picture of contemporary programming paradigms by means of one language.