Functional Programming

Data science has emerged as a critical field driving innovation and decision-making across industries. At its core, data science relies on efficient data manipulation, rigorous statistical analysis, sophisticated machine learning model development, and compelling data visualization. This research paper argues for the indispensable role of Python programming in facilitating these core data science activities. We will explore Python's key advantages, including its comprehensive ecosystem of libraries, ease of learning, versatility, and robust community support, demonstrating why it has become the de facto language for data scientists worldwide. Furthermore, we will analyze its suitability for various stages of the data science pipeline, from data acquisition and preprocessing to model deployment and reporting, solidifying its necessity in the modern data science landscape.

Since the approach of building specialized systems from existing general-purpose components is becoming more common, there is a growing need for global optimization tools that accomplish the functional requirements of these systems. The first approach for developers is to apply the current optimization techniques individually on each component. Nevertheless, these optimizations do not always improve the code enough and manual tuning must be done afterward. This paper presents a new approach for global optimization based on building a global view of the system, a global control flowgraph. The paper summarizes relevant characteristics of the system components to build a global view and presents particular examples for different architectures (PowerPC and x86) and operating systems (based on L4 µkernel and Linux kernel). Our evaluations show that typical optimizations on a specific embedded environment reduce the code size by up to 54%.

Tracing program executions is a promising technique to find bugs in lazy functional logic programs. In previous work we developed an extension of a heap based semantics for functional logic languages which generates a trace reflecting the computation of the program. This extension was also prototypically implemented by instrumenting an interpreter for functional logic programs. Since this interpreter is too restricted for real world applications, we developed a program transformation which efficiently computes the trace by means of side effects during the computation. This paper presents our program transformation.

There exist several implementations of the functional logic lan-guage Curry: a transformation to Prolog and implementations of abstract machines for C and Java. We show that there are many advantages of a further implementation as a transformation to Haskell: increases in performance, availability of libraries and tools, and open access to the implementation. We present the ba-sic ideas and a prototypical implementation of our transformation, which generates Haskell programs without use of impure features.

Tracing program executions is a promising technique to find bugs in lazy functional logic programs. In previous work we developed an extension of a heap based semantics for functional logic languages which generates a trace reflecting the computation of the program. This extension was also prototypically implemented by instrumenting an interpreter for functional logic programs. Since this interpreter is too restricted for real world applications, we developed a program transformation which efficiently computes the trace by means of side effects during the computation. This paper presents our program transformation.

In this work, we introduce a profiling scheme for modern functional logic languages covering notions like laziness, sharing, and non-determinism. Firstly, we instrument a natural (big-step) semantics in order to associate a symbolic cost to each basic operation (e.g., variable updates, function unfoldings, case evaluations). While this cost semantics provides a formal basis to analyze the cost of a computation, the implementation of a cost-augmented interpreter based on it would introduce a huge overhead. Therefore, we also introduce a sound transformation that instruments a program such that its execution-under the standard semantics-yields not only the corresponding results but also the associated costs. Finally, we describe a prototype implementation of a profiler based on the developments in this paper.

Most implementations of functional and functional logic languages treat numbers and the basic numeric operations as external entities. The main reason for this is efficiency. However, this basic design decision has many unfortunate consequences for all programs using numbers. We present an approach to model numbers in a declarative way and argue that the loss in efficiency is compensated by the newly gained possibilities. Functional logic languages benefit the most from this proposal because all the numeric operations become fully narrowable. This enables the solving of simple equations on numbers in an efficient way without having to resort to external constraint solvers. The presented approach can either be used as a library for purely declarative numbers or it can be employed as a basic data type of functional (logic) languages. Indeed, we have integrated the presented data structures as the only numbers available in our compiler for the functional logic language Curry and have experienced several months of satisfactory performance.

A lightweight approach to debugging functional logic programs by observations is presented, implemented for the language Curry. The Curry Object Observation System (COOSy) comprises a portable library plus a viewing tool. A programmer can observe data structures and functions by annotating expressions in his program. The possibly partial values of observed expressions that are computed during program execution are recorded in a trace file, including information on non-deterministic choices and logical variables. A separate viewing tool displays the trace content. COOSy covers all aspects of modern functional logic multiparadigm languages such as lazy evaluation, higher order functions, non-deterministic search, logical variables, concurrency and constraints. Both use and implementation of COOSy are described.

Functional programming languages are particularly well-suited for building automated reasoning systems, since (among other reasons) a logical term is well modeled by an inductive type, traversing a term can be implemented generically as a higher-order combinator, and backtracking search is dramatically simplified by persistent datastructures. However, existing pure functional programming languages all suffer a major limitation in these domains: traversing a term requires time proportional to the tree size of the term as opposed to its graph size. This limitation would be particularly devastating when building automation for interactive theorem provers such as Lean and Coq, for which the exponential blowup of term-tree sizes has proved to be both common and difficult to prevent. All that is needed to recover the optimal scaling is the ability to perform simple operations on the memory addresses of terms, and yet allowing these operations to be used freely would clearly violate the ba...

Welcome to ELS 2011, the 4 th European Lisp Symposium. In the recent years, all major academic events have suffered from a decreasing level of attendance and contribution, Lisp being no exception to the rule. Organizing ELS 2011 in this context was hence a challenge of its own, and I'm particularly happy that we have succeeded again. For the first time this year, we had a "special focus" on parallelism and efficiency, all very important matters for our community with the advent of multi-core programming. It appears that this calling has been largely heard, as half of the submissions were along these lines. Another notable aspect of this year's occurrence is the fact that four dialects of Lisp are represented: Common Lisp, Scheme, Racket and Clojure. This indicates that ELS is successful in attempting to gather all crowds around Lisp "the idea" rather than around Lisp "one particular language". The European Lisp Symposium is also more European than ever, and in fact, more international than ever, with people coming not only from western Europe and the U.S.A., but also from such countries as Croatia and Bulgaria. While attending the symposium is just seeing the tip of the iceberg, a lot have happened underwater. First of all, ELS 2011 would not have been possible without the submissions we got from the authors and the careful reviews provided by the programme committee members; I wish to thank them for that. I am also indebted to the keynote speakers who have agreed to come and spread the good word. I wish to express my utmost gratitude to our sponsors who contributed to making the event quite affordable this year again. Ralf Möller was our local chair, the "Grey Eminence" of the symposium, and we owe him a lot. Finally, my thanks go to Edgar Gonçalves for taking care of the website with such reactivity and attentiveness. I wish you all a great symposium! Welcome to Hamburg University of Technology (TUHH). We hope you will enjoy your stay at our university for the 2011 European Lisp Symposium. Not only interesting presentations will be part of the programme, but also social events such as the the social dinner at the Feuerschiff () and the Welcome Reception at Freiheit (). We would like to thank all sponsors for making the event possible. For those of you staying over the weekend, a tour to Miniatur-Wunderland (. miniatur-wunderland.de) will be offered. ELS 2011 iii TUHH () is a competitive entrepreneurial university focussing on highlevel performance and high quality standards. TUHH is dedicated to the principles of Humboldt (unity of research and education). TUHH has a strong international orientation and also focusses on its local environment. It contributes to the development of the technological and scientific competence of society, aiming at excellency at the national and international level in its strategic research fields, and educating young scientists and engineers within demanding programmes using advanced teaching methods. Let's not forget Hamburg, for why are we all here? People say Hamburg is Germany's most attractive city combining urbane sophistication, maritime flair, the open-mindedness of a metropolis, and high recreational value. The second-largest city in Germany, it has traditionally been seen as a gateway to the world. Its port is not only the largest seaport in Germany and the second-largest in Europe, but a residential neighborhood with leisure, recreational and educational facilities. Hamburg is a very special place.

The Common Lisp metaobject protocol specifies a generic function named make-method-lambda to be called at macro-expansion time of the macro defmethod. In an article by Costanza and Herzeel, a number of problems with this generic function are discussed, and a solution is proposed. In this paper, we show that the alleged problems are due to the fact that existing implementations do not include proper compiletime processing of the associated macro defgeneric, and that with proper compile-time processing, the problems indicated in the paper by Costanza and Herzeel simply vanish. The main characteristic of our proposed solution is for the compile-time side effects of defgeneric to include saving the name of the method class given as an option to that macro call. With this additional information, no difference exists between the behavior of direct evaluation and that of file compilation of a defgeneric form and a defmethod form mentioning the same name of the generic function.

This paper explores the work of John McCarthy on the LISP programming language and focuses on its underlying functional paradigms, its everlasting influence today, and its application in modern programming. The central research question is: In what way do the functional programming paradigms introduced in LISP contribute to the development of more reliable and maintainable software? A major challenge in modern-day software development is ensuring correctness and a lack of runtime issues. As programs grow in complexity, stateful monolithic functions with mutable states become harder to properly test. This leads to untested and unreliable programs, which are difficult to validate. LISP introduced key concepts, such as recursion, immutability, and functions as first-class citizens, that offer promising solutions to these issues. We will explore through logical reasoning how LISP's functional design allows for a more predictable program execution, supports testing philosophies, and how its modularity aids in collaborative development. Although empirical studies on this topic are still emerging, theoretical and practical evidence suggest its usefulness in modern software development.

The use of algorithmic skeletons in parallel functional programming seems to overcome many of the problems functional languages have in their applicability for applications. This paper presents a parallel implementation method for the SIT skeleton which takes into account all the available information about its behaviour in order to produce an e cient implementation on a parallel computer.

Time is a valuable resource, and efficiency is crucial for algorithm development. Programmers must find and write efficient algorithms with the best time complexity. Several factors affect the performance of an algorithm, such as programming languages, hardware and software requirements, and algorithm design (Iterative vs Recursive). In this paper, we will use empirical analysis to measure the performance of four functions with an input n until the maximum value the system can handle.

We give a complete, framework-independent proof that the class P of languages decidable in deterministic polynomial time coincides with the class DYP: languages decided by polytimeuniform, polynomial-size dynamic-programming computation DAGs over any fixed finite basis of constant-arity Boolean operators. We prove DYP ⊆ P by direct topological evaluation, and P ⊆ DYP via two standard, independent normalizations: (i) through polytime-uniform Boolean circuit families, and (ii) through a direct tableau (space-time grid) unrolling of a polynomial-time Turing machine. We also discuss robustness to the choice of local operator basis (including "min"/+ aggregators over {0, 1}) and uniformity conventions. Our proof uses only textbook results about uniform circuits and TM simulations.

Some software measures are still not widely used in industry, despite the fact that they were defined many years ago, and some additional insights might be gained by revisiting them today with the benefit of recent lessons learned about how to analyze their design. In this paper, we analyze the design and definitions of Halstead's metrics, the set of which is commonly referred to as 'software science'. This analysis is based on a measurement analysis framework defined to structure, compare, analyze and provide an understanding of the various measurement approaches presented in the software engineering measurement literature.

Agile programming emphasizes adaptability, iteration, and collaboration in software development. With the rise of quantum computing, new paradigms of probabilistic and hybrid computation challenge conventional Agile workflows. This paper proposes the W-Lambda framework, a waveform calculus that unifies Agile iteration cycles, quantum uncertainty, and reflexivity in organizational systems. Furthermore, we introduce resilience as conceptualized by Professor Levi, modeling the system's capacity to absorb disturbances, adapt dynamically, and recover efficiently. By integrating philosophical perspectives (Sun Tzu, Popper, Soros) with mathematical models of quantum algorithms, W-Lambda dynamics, and resilience operators, we present a new vision of software development as a waveform process that is adaptive, robust, and value-driven.

In 2014, Fire & Rescue New South Wales piloted the delivery of its home fire safety checks program (HFSC) aimed at engaging and educating targeted top "at risk" groups to prevent and prepare for fire. This pilot study aimed to assess the effectiveness of smoke alarms using a cluster randomized controlled trial. Methods: Survey questionnaires were distributed to the households that had participated in the HFSC program (intervention group). A separate survey questionnaire was distributed to the control group that was identified with similar characteristics to the intervention group in the same suburb. To adjust for potential clustering effects, generalized estimation equations with a log link were used. Results: Multivariable analyses revealed that battery and hardwired smoking alarm usage increased by 9% and 3% respectively among the intervention group compared to the control group. Females were more likely to install battery smoke alarms than males. Respondents who possessed a certificate or diploma (AOR = 1.31, 95% CI 1.00-1.70, P = 0.047) and those who were educated up to years 8-12 (AOR = 1.32, 95% CI 1.06-1.64, P = 0.012) were significantly more likely to install battery smoke alarms than those who completed bachelor degrees. Conversely, holders of a certificate or diploma and people who were educated up to years 8-12 were 31% (AOR = 0.69, 95% CI 0.52-0.93, P = 0.014) and 24% (AOR = 0.76, 95% CI 0.60-0.95, P = 0.015) significantly less likely to install a hardwired smoke alarm compared to those who completed bachelor degrees. Conclusions: This pilot study provided evidence of the benefit of the HFSC in New South Wales. Practical Applications: Fire safety intervention programs, like HFSC, need to be targeted to male adults with lower level of schooling even when they are aware of their risks.

This project is part of a master's thesis to implement eLTL logic, UMA University (Spain).
A Flink application project using Scala to implement Event-driven Interval Temporal Logic (eLTL) that extends Linear temporal logic LTL for analysing hybrid systems.

This paper introduces the Lambda-Wave Calculus (W), a novel synthesis of lambda calculus and wave mechanics. We propose interpreting lambda abstractions as wave operators and applications as interference events, thereby mapping symbolic computation to physical wave dynamics. The framework provides a rigorous yet creative foundation for OpenWave, an approach that views open-source ecosystems as distributed resonant wavefields. Cultural analogies from DJ music mixing are incorporated to illustrate how formal structures can manifest as live, creative waveform computation.

In this paper, we present a variational framework for joint disparity and motion estimation in a sequence of stereo images. The problem involves the estimation of four dense fields: two motion fields and two disparity fields. In order to reduce computational complexity and improve estimation accuracy, the two motion fields, for the left and right sequences, and the disparity field of the current stereo pair are jointly estimated, using the stereo-motion consistency constraint. In the proposed variational framework, the joint estimation problem is formulated as a convex programming problem in which a convex objective function is minimized under specific convex constraints. This minimization is achieved using an efficient parallel block-iterative algorithm. Experimental results involving real stereo sequences indicate the feasibility and robustness of our approach.

Classical mechanics is deceptively simple. It is surprisingly easy to get the right answer with fallacious reasoning or without real understanding. To address this problem we use computational techniques to communicate a deeper understanding of Classical Mechanics. Computational algorithms are used to express the methods used in the analysis of dynamical phenomena. Expressing the methods in a computer language forces them to be unambiguous and computationally effective. The task of formulating a method as a computerexecutable program and debugging that program is a powerful exercise in the learning process. Also, once formalized procedurally, a mathematical idea becomes a tool that can be used directly to compute results.

Classical mechanics is deceptively simple. It is surprisingly easy to get the right answer with fallacious reasoning or without real understanding. To address this problem we use computational techniques to communicate a deeper understanding of Classical Mechanics. Computational algorithms are used to express the methods used in the analysis of dynamical phenomena. Expressing the methods in a computer language forces them to be unambiguous and computationally effective. The task of formulating a method as a computerexecutable program and debugging that program is a powerful exercise in the learning process. Also, once formalized procedurally, a mathematical idea becomes a tool that can be used directly to compute results.

We would like to thank the many people who have helped us to develop this book and the curriculum that it is designed to support. We have had substantial help from the wonderful students who studied with us in our classical mechanics class. They have forced us to be clear; they have found bugs that we had to fix, in the software, in the presentation, and in our thinking. We have had considerable technical help in the development and presentation of the subject matter from Harold Abelson. Abelson is one of the developers of the Scmutils software system. He put mighty effort into some sections of the code. We also consulted him when we were desperately trying to understand the logic of mechanics. He often could propose a direction to lead out of an intellectual maze. Matthew Halfant started us on the development of the Scmutils system. He encouraged us to get into scientific computation, using Scheme and functional style as an active way to explain the ideas, without the distractions of imperative languages such as C. In the 1980's he wrote some of the early Scheme procedures for numerical computation that we still use. Dan Zuras helped us with the invention of the unique organization of the Scmutils system. It is because of his insight that the system is organized around a generic extension of the chain rule for taking derivatives. He also helped in the heavy lifting that was required to make a really good polynomial GCD algorithm, based on ideas that we learned from Richard Zippel. This book, and a great deal of other work of our laboratory, could not have been done without the outstanding work of Chris Hanson. Chris developed and maintained the Scheme system underlying this work. In addition, he took us through a pass of reorganization of the Scmutils system that forced the clarification of many of the ideas of types and of generic operations that make our system as good as it is. Guillermo Juan Rozas, co-developer of the Scheme system, made major contributions to the Scheme compiler, and imple-xviii Acknowledgments mented a number of other arcane mechanisms that make our system efficient enough to support our work. Besides contributing to some of the methods for the solution of linear equations in the Scmutils system, Jacob Katzenelson has provided valuable feedback that improved the presentation of the material. Julie Sussman, PPA, provided careful reading and serious criticism that forced us to reorganize and rewrite major parts of the text. She also developed and maintained Gerald Jay Sussman over these many years. Cecile Wisdom, saint, is a constant reminder, by her faith and example, of what is really important. This project would not have been possible without the loving support and unfailing encouragement she has given Jack Wisdom. Their children, William, Edward, Thomas, John, and Elizabeth Wisdom, each wonderfully created, daily enrich his life with theirs. Meinhard Mayer wants to thank Rita Mayer, for patient moral support, particularly during his frequent visits to MIT during the last 12 years; Niels Mayer for introducing him to the wonderful world of Scheme (thus sowing the seeds for this collaboration), as well as Elma and the rest of the family for their love. Many have contributed to our understanding of dynamics over the years. Michel Henon and Boris Chirikov have had particular influence. Stan Peale, Peter Goldreich, Alar Toomre, and Scott Tremaine have been friends and mentors. We thank former students Jihad Touma and Matthew Holman, for their collaboration and continued friendship. We have greatly benefited from associations with many in the nonlinear dynamics community: Tassos

We propose a rule-based system built on top of the capabilities of Mathematica to program non-deterministic and partially defined computations. The system is called ρLog and has primitive operators for defining elementary rules and for computing with unions, compositions, reflexive-transitive closures, and normal forms of rule applications. Moreover, ρLog can compute proof objects, which are internal representations of deduction derivations which respect a specification given by the user. We describe the programming principles and constructs of ρLog, the structures used to encode deduction derivations, and the methods provided to manipulate and visualize them. ρLog is a renamed version of the rule-based programming system FunLog [9, 10]. We did this in order to avoid confusing it with FUNLOG [12], a system for functional programming and logic programming developed in the eighties. Like Elan [2], ρLog provides a suitable environment for specifying and implementing deduction systems in a language based on rewrite rules whose application is controlled by user-defined strategies. More precisely, ρLog allows to:

Abstract. Transformation rules are a convenient means to specify partially defined and nondeterministic computations. We describe a rulebased programming system which has primitive operators for defining elementary rules and for computing with unions, ...

Maude is a wide-spectrum reflective logical language based on rewriting logic that can be used to specify, prototype, and formally analyze concurrent software systems, specification languages, logics, and theorem provers. Because of its efficient implementation, it can also be used as a programming language and as a meta-tool to generate other tools. This paper gives a brief introduction to the language and illustrates with examples some of the features of the current version, available free of charge together with examples, documentation, and papers from SRI: see . The key characteristics of Maude can be summarized as follows: -Based on rewriting logic. This makes it particularly well suited to express concurrent and state-changing aspects of systems declaratively. -Wide-spectrum. Rewriting logic is a logical and semantic framework for both specification and efficient execution. -Multiparadigm. Since rewriting logic conservatively extends equational logic, an equational style of functional programming is naturally supported in a sublanguage. A declarative style of concurrent object-oriented programming is also supported with a simple logical semantics. -Reflective. Rewriting logic is reflective . The design of Maude capitalizes on this fact to support a novel style of metaprogramming with very powerful module-combining and module-transforming operations that surpass those of traditional parameterized programming. -Internal Strategies. The strategies controlling the rewriting process can be defined by rewrite rules and can be reasoned about inside the logic [4, 5, 1]. Maude's implementation has been designed with the explicit goals of supporting executable specification and formal methods applications, of being easily extensible, and of supporting reflective computations. Although it is an interpreter, its advanced semicompilation techniques support flexibility and traceability without sacrificing the performance of up to 1.665 million rewrites per second in the free theory and between 131 thousand, and 1 million rewrites per second if associativity and commutativity axioms are used, on a 500MHz Alpha.

Maude i s a h igh-level l anguage a nd a h igh-performance s ystem s upporting e xecutable speciÿ-cation a nd d eclarative p rogramming i n r ewriting l ogic. S ince r ewriting l ogic contains e quational l ogic, Maude a lso s upports e quational s peciÿcation a nd p rogramming i n its s ublanguage o f f unc-tional modules a nd t heories. T he u nderlying e quational l ogic chosen f or Maude i s membership e quational l ogic, t hat h as s orts, s ubsorts, o perator overloading, a nd p artiality d eÿnable b y mem-bership a nd e quality c onditions. Rewriting l ogic is r e ective, i n t he s ense o f b eing a ble t o e xpress i ts o wn metalevel a t t he o bject l evel. Re ection i s s ystematically e xploited i n Maude e ndowing t he l anguage with p owerful metaprogramming c apabilities, i ncluding b oth u ser-deÿnable module o perations a nd declarative s trategies t o g uide t he d eduction p rocess. T his p aper e xplains a nd i llustrates with e xamples t he main c oncepts o f Maude's l anguage d esign, i ncluding i ts u nder-lying logic, f unctional, s ystem a nd o bject-oriented modules, a s well a s p arameterized modules, theories, a nd v iews. We a lso e xplain h ow Maude s upports r e ection, metaprogramming a nd in-ternal s trategies. T he p aper o utlines t he p rinciples u nderlying t he Maude s ystem implementation, i ncluding i ts s emicompilation t echniques. We c onclude with s ome r emarks about a pplications, work o n a f ormal e nvironment f or Maude, a nd a mobile l anguage extension o f Maude.

While the ability to simulate nondeterminism and compute multiple solutions for a single query is a powerful and attractive feature of logic programming languages, it is expensive in both time and space. Since programs in such languages are very often functional, i.e. do not produce more than one distinct solution for a single input, this overhead is especially undesirable. This paper describes how programs may be analyzed statically to determine which literals and predicates are functional, and how the program may then be optimized using this information. Our notion of ''functionality'' subsumes the notion of ''determinacy'' that has been considered by various researchers. Our algorithm is less reliant on language features such as the cut, and thus extends more easily to parallel execution strategies, than others that have been proposed.

Although the ability to simulate nondeterminism and to compute multiple solutions for a single query is a powerful and attractive feature of logic programming languages, it is expensive in both time and space. Since programs in such languages are very often functional, that is, they do not produce more than one distinct solution for a single input, this overhead is especially undesirable. This paper describes how programs may be analyzed statically to determine which literals and predicates are functional, and how the program may then be optimized using this information. Our notion of “functionality” subsumes the notion of “determinacy” that has been considered by various researchers. Our algorithm is less reliant on language features such as the cut, and thus extends more easily to parallel execution strategies, than others that have been proposed.

In modern functional logic languages like Curry or Toy, programs are possibly nonconfluent and non-terminating rewrite systems, defining possibly non-deterministic non-strict functions. Therefore, equational reasoning is not valid for deriving properties of such programs. In a previous work we showed how a mapping from CRWL -a well known logical framework for functional logic programming-into logic programming could be in principle used as logical conceptual tool for proving properties of functional logic programs. A severe problem faced in practice is that simple properties, even if they do not involve non-determinism, require difficult proofs when compared to those obtained using equational specifications and methods. In this work we improve our approach by taking into account determinism of (part of) the considered programs. This results in significant shortenings of proofs when we put in practice our methods using standard systems supporting equational reasoning like, e.g., Isabelle.

Bidirectional transformations (BXs) are a mechanism for maintaining consistency between multiple representations of related data. The lens framework, which usually constructs BXs from lens combinators, has become the mainstream approach to BX programming because of its modularity and correctness by construction. However, the involved bidirectional behaviors of lenses make the equational reasoning and optimization of them much harder than unidirectional programs. We propose a novel approach to deriving efficient lenses from clear specifications via program calculation, a correct-by-construction approach to reasoning about functional programs by algebraic laws. To support bidirectional program calculation, we propose contract lenses, which extend conventional lenses with a pair of predicates to enable safe and modular composition of partial lenses. We define several contract-lens combinators capturing common computation patterns including $\textit{fold}, \textit{filter},\textit{map}$ ...

Defining functions by pattern matching over the arguments is advantageous for understanding and reasoning, but it tends to expose the implementation of a datatype. Significant effort has been invested in tackling this loss of modularity; however, decoupling patterns from concrete representations while maintaining soundness of reasoning has been a challenge. Inspired by the development of invertible programming, we propose an approach to program refactoring based on a right-invertible language rinv-every function has a right (or pre-) inverse. We show how this new design is able to permit a smooth incremental transition from programs with algebraic datatypes and pattern matching, to ones with proper encapsulation, while maintaining simple and sound reasoning.

Matsuda et al. (Matsuda, K., Hu, Z., Nakano, K., Hamana, M. & Takeichi, M. (2007) Bidirectionalization transformation based on automatic derivation of view complement functions. In Proceedings of the International Conference on Functional Programming. ACM Press, pp. 47–58) and Voigtländer (Voigtländer, J. (2009) Bidirectionalization for free! In Proceedings of Principles of Programming Languages. ACM Press, pp. 165–176) have introduced two techniques that given a source-to-view function provide an update propagation function mapping an original source and an updated view back to an updated source, subject to standard consistency conditions. Previously, we developed a synthesis of the two techniques, based on a separation of shape and content aspects (Voigtländer, J., Hu, Z., Matsuda, K. & Wang, M. (2010) Combining syntactic and semantic bidirectionalization. In Proceedings of the International Conference on Functional Programming. ACM Press, pp. 181–192). Here we carry that idea fur...

We describe an approach to introducing non-science majors to programming and computation in part by teaching them applets, servlets, and groupware applications. The course uses a dialect of didactic Scheme that is implemented in, and tightly integrated with, Java. The declarative nature of our approach allows non-science majors with no programming background to develop surprisingly complex web applications in about half a semester. This level of programming provides a context for a deeper understanding of computation than is usually feasible in a Computer Literacy course.

This paper consists of two parts: the first provides the theoretical foundations for analyzing parallel programs and illustrates how the theory can be applied to estimate the execution time of a class of parallel programs being executed on a MIMD computer. The second part describes a program analysis system, based on the theoretical model, which allows a user to interactively analyze the results of executing (or simulating the execution) of such parallel programs. Several examples illustrating the use of the tool are presented. A novel contribution is the separation (both at the conceptual and the implementation levels) of the machine-independent and the machine-dependent parts of the analysis. This separation enables the users of the system to establish speed-up curves for machines having varying characteristics.

Language constructs inspired by functional programming have made their way into most mainstream programming languages. Many researchers and developers consider that these constructs lead to programs that are more concise, reusable, and easier to understand. Notwithstanding, few studies investigate the prevalence of these structures and the implications of using them in mainstream programming languages. This paper quantifies the prevalence of four concepts typically associated with functional programming in JavaScript: recursion, immutability, lazy evaluation, and functions as values. We divide the latter into two groups, higher-order functions and callbacks & promises. We focus on JavaScript programs due to the availability of some of these concepts in the language since its inception, its inspiration from functional programming languages, and its popularity. We mine 91 GitHub repositories (more than 22 million LOC) written mostly in JavaScript (over 50% of the code), measuring the usage of these concepts from both static and temporal perspectives. We also measure the likelihood of bugfixing commits removing uses of these concepts (which would hint at bug-proneness) and their association with the presence of code comments (which would hint at code that is hard to understand). We find that these concepts are in widespread use (478,605 occurrences, 1 for every 46.65 lines of code, 43.59% of LOC). In addition, the usage of higher-order functions, immutability, and lazy evaluation-related structures has been growing throughout the years for the analyzed projects, while the usage of recursion and callbacks & promises has decreased. We also find statistical evidence that removing these structures, with the exception of the ones associated to immutability, is less common in bug-fixing commits than in other commits. In addition, their presence is not correlated with comment size. Our findings suggest that functional programming concepts are important for developers using a multi-paradigm language such as JavaScript, and their usage does not make programs harder to understand.

Meta-Vectors introduce a novel algebraic paradigm designed to unify multi-dimensional computation, symbolic reasoning, and structural dynamics. Unlike traditional tensor systems, Meta-Vectors integrate three layers—algebraic operations, functional transformations, and procedural logic—into a single recursive framework. We formalize Meta-Vector spaces with axioms, operators, and invariants, establishing closure properties, compositional semantics, and a meta-metric for structural divergence. Computational complexity analysis demonstrates favorable scaling compared to tensor architectures under multi-layer composition. Applications span artificial intelligence, robotics, physics simulations, and quantum-classical hybrid systems, offering a foundation for next-generation computational mathematics and adaptive symbolic systems.

The field of formal methods has grown significantly over the last few years because of the increased need for software systems that are error-free and reliable. Formal computer programming applies mathematical underpinnings to define, design, and prove computer programs rigorously. This research article explains the concept of formal computer programming, with focus on two important topics: Semantic Foundations for Software Engineering and Lightweight Formal Methods for Programming. The article puts forward the place of semantics in programming language understanding and their enactment, as well as lightweight formal methods that make practical application of formal techniques in real software development possible. The article also examines the trade-offs, challenges, and future directions of applying these methods in industry and academia.

HAL is a multi-disciplinary open access archive for the deposit and dissemination of scientific research documents, whether they are published or not. The documents may come from teaching and research institutions in France or abroad, or from public or private research centers. L'archive ouverte pluridisciplinaire HAL, est destinée au dépôt et à la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d'enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.

The theory of object-oriented programming (OOP) has been used as a paradigm in the development of software engineering that has lasted over a few decades. Although software industry is changing rapidly with other languages and paradigm, OOP now is very much present in the design and architecture of present day systems. An example of the survival of theoretical concepts is the .NET platform which started with early Common Language Runtime (CLR) and more recently modern ASP.NET Core framework and more up-to-date versions of the C# programming language, covering encapsulation, polymorphism, inheritance and abstraction.
This paper therefore seeks to address how the fundamental OOP concepts were used in creating the .NET ecosystem and how it mutated. It aims to understand what these principles are embodied in such aspects as runtime behaviors, language features, framework architecture, and design practice. The paper, using qualitative thematic synthesis on 30 peer-reviewed scholarly articles, theses, technical reports, and case-based assessments fuses theoretical framework with practice forms of implementation at various levels of .NET.
The findings reveal a consistent alignment between .NET's design philosophy and object-oriented theory. These values have been retained by key features like use of generics, dependency injection, interface programming, and popularization of design patterns. Additionally, more recent C# additions such as LINQ, immutable records, pattern matching, and async/ await reveal a practical shift to hybridization: merging the idea of functional programming performance and structure, with OO program modularity.
Quantitative measurements indicated multi-threaded queries performed at 25%-35% higher level using PLINQ vs. the traditional LINQ, in multicore scenarios. The boxing overhead was minimized and memory consumption improved by up to 20% through the use of generic collections in .NET. Entity Framework queries with LINQ demonstrated an increase of up to 30% in readability and maintainability with no decrease in the performance at run time.
These findings indicate that OOP still offers sustainable and flexible model of regulating software complexity especially in large-sized enterprise systems. Although it is a subject of discussions regarding its theoretical limitations, the real-life experience of the evolution of .NET platforms clearly points to that the OOP is relevant in the development of scalable, maintainable, and robust applications.
The study comes to the conclusion that the OOP theory is not the one that is only historically important but the one that is actively used in designing the more recent programming platform, such as the .NET. With the current trend toward hybrid and multiparadigm languages, the interface of the OOP theory to such systems as the .NET platform would provide a great point of view in both educational and business spheres. The study confirms both the current relevance of OOP in the current software infrastructure and predisposes the chance to research the paradigm convergence, language design, and architectural resilience in the high-scale environments.

We consider the problem of inferring a grammar describing the output of a functional program given a grammar describing its input. Solutions to this problem are helpful for detecting bugs or proving safety properties of functional programs, and several rewriting tools exist for solving this problem. However, known grammar inference techniques are not able to take evaluation strategies of the program into account. This yields very imprecise results when the evaluation strategy matters. In this work, we adapt the Tree Automata Completion algorithm to approximate accurately the set of terms reachable by rewriting under the innermost strategy. We formally prove that the proposed technique is sound and precise w.r.t. innermost rewriting. We show that those results can be extended to the leftmost and rightmost innermost case. The algorithms for the general innermost case have been implemented in the Timbuk reachability tool. Experiments show that it noticeably improves the accuracy of static analysis for functional programs using the call-by-value evaluation strategy.

We consider the problem of reconciling a dependently typed functional language with imperative features such as mutable higher-order state, pointer aliasing, and nontermination. We propose Hoare type theory (HTT), which incorporates Hoare-style specifications into types, making it possible to statically track and enforce correct use of side effects. The main feature of HTT is the Hoare type {P }x:A{Q} specifying computations with precondition P and postcondition Q that return a result of type A. Hoare types can be nested, combined with other types, and abstracted, leading to a smooth integration with higher-order functions and type polymorphism. We further show that in the presence of type polymorphism, it becomes possible to interpret the Hoare types in the "small footprint" manner, as advocated by separation logic, whereby specifications tightly describe the state required by the computation. We establish that HTT is sound and compositional, in the sense that separate verifications of individual program components suffice to ensure the correctness of the composite program.

The FOLD v1 Specification defines a functional, category-inspired language for structural computation, physical modeling, and coherence-driven systems. Built on the principles of recursive generation, morphic depth, and coherence, FOLD unifies declarative expressiveness with constraint-based operational semantics. All computation is formulated as convergence toward structural fixpoints under explicit frames, with a minimal, extensible operator set and dual canonical/sugar syntax. The language features a structural type system, rational and real numeric domains, solver integration, and a standard library supporting advanced operations such as partition, entanglement, and optimization. All constructs are compositional, referentially transparent, and grounded in the formal requirements of Fold Theory. Reserved features include surreal number support and superposition-based modeling for future versions. This specification serves as the authoritative reference for language implementers, theorists, and advanced users seeking principled modeling of emergent and constraint-driven systems.