Search

Artillery designers are always searching for means of improving a gun's external and internal ballistic properties and this resulted in both new theories surrounding gun construction based on the properties of materials and new methods of building guns capable of firing heavier projectiles to greater ranges. The concept of the accelerator gun sought to achieve the same result without the need for larger and heavier guns and reducing recoil through the use of multiple propellant charges fired sequentially, thus accelerating the projectile without the need for a single high-pressure discharge. It was a quest initiated in France, pursued in the United States and then adopted by a desperate Germany during the latter years of World War 2. [ABSTRACT FROM AUTHOR]

The conjunctive normal form (CNF) algorithm is one of the best known and most widely used algorithms in classical logic and its applications. In its algebraic approach, it makes use in a loop of a certain well-defined operation related to the "distributivity" of logical disjunction versus conjunction. For those types of implementations, the loop iteration runs a comparison between formulas to decide when to stop. In this article, we explain how to pre-calculate the exact number of loop iterations, thus avoiding the work involved in the above-mentioned comparison. After that, it is possible to concatenate another loop focused now on the "associativity" of conjunction and disjunction. Also for that loop, we explain how to calculate the optimal number of rounds, so that the decisional comparison phase for stopping can be also avoided. [ABSTRACT FROM AUTHOR]

Pattern matching is an important language construct for data abstraction. Many pattern-match extensions have been developed for extending the range of data types to which pattern matching is applicable. Among them, the pattern-match system proposed by Egi and Nishiwaki features practical pattern matching for non-free data types by providing a user-customizable non-linear pattern-match facility with backtracking. However, they implemented their proposal only in dynamically typed programming languages, and there were no proposals that allow programmers to benefit from both static type systems and expressive pattern matching. This paper proposes a method for implementing this pattern-match facility by meta-programming in Haskell. There are two technical challenges: (i) we need to design a set of typing rules for the pattern-match facility; (ii) we need to embed these typing rules in Haskell to make types of the pattern-match expressions inferable by the Haskell type system. We propose a set of typing rules and show that several GHC extensions, such as multi-parameter type classes, datatype promotion, GADTs, existential types, and view patterns, play essential roles for embedding these typing rules into Haskell. The implementation has already been distributed as a Haskell library miniEgison via Hackage. [ABSTRACT FROM AUTHOR]

We present a new modular proof method of termination for second-order computation, and report its implementation SOL. The proof method is useful for proving termination of higher-order foundational calculi. To establish the method, we use a variation of the semantic labelling translation and Blanqui's General Schema: a syntactic criterion of strong normalisation. an application, we show termination of a variant of call-by-push-value calculus with algebraic effects, an effect handler and effect theory. We also show that our tool SOL is effective to solve higher-order termination problems. [ABSTRACT FROM AUTHOR]

A simple procedural programming language is considered, each program of which can input integer values, process them and output new integer values as result. A program is a block with description of local integer variables and procedures and a list of statements. The language has data processing statements: assignment, input, output, conditional, loop, procedure call and block. Main purpose of the block is to enter local data (integer variables and procedures) that are used in the body of the block - a list of operators. The scope of the name of the local data described in the block is the text of the block except for nested blocks, where this name is redefined. A mechanism of automatic memory allocation for variables entered in the block is also associated with the block. Memory for local variables is allocated when entering a block, and freed when exiting a block. A block containing only a list of statements is valid. The procedure has a name, list of formal parameters, and a body - a statement (most often a block). Formal parameters are applied only in its body. A procedure is calculated by the procedure call statement, whose actual parameters are only variables. Parameters are passed by reference (pass-by-reference). A formal specification of a programming language is a description of its syntax and semantics. A concrete syntax, finite set of rules, singles out syntactically correct sequences of symbols of the alphabet of language. To describe the semantics of a language, as a rule, abstract syntax is used, adding contextual conditions to it. The task of semantics is to introduce the denotations ("meanings") of the basic constructions of language and semantic functions that build the denotations of complex syntactic constructions based on the denotations of their components, including the program. The article provides a specification of a procedural programming language that uses the extended Backus-Naur form to describe a concrete syntax, and the tools of the functional language Haskell to describe other parts. Abstract syntax is defined by the types Program, Proc, Stmt, Expr and Op. Additional contextual conditions are predicates that use information about program data. Most of the context conditions are related to the correct use of data in the program. The leading predicate that checks the context conditions of the program pr is iswfProgram pr. The language denotations are based on the Work type. The value of this type - a tuple (inp, stg, out) models the environment in which the language program is executed: inp - input data, stg - memory containing variable values, out - resulting data. The semantics of main constructions procedure, statement and expression are functions of the type Work -> Work or Work -> Integer. The semantics of the program is a function of the type [Integer] -> [Integer]. Semantic functions build these denotations according to syntactic constructions, which are described by abstract syntax - Proc, Stmt, Expr, Program types. The semantics of the program (Program) pr is built by function iProgram pr. All functions: contextual conditions, denotations and semantic functions are pure functions. Using Haskell tools, a function called parsePLL is built, which connects concrete and abstract syntax. It is shown how by combining the functions parsePLL, iswfProgram and iProgram you can get a procedural language - a pure function with the name interpret. [ABSTRACT FROM AUTHOR]

Differential privacy offers a formal framework for reasoning about the privacy and accuracy of computations on private data. It also offers a rich set of building blocks for constructing private data analyses. When carefully calibrated, these analyses simultaneously guarantee the privacy of the individuals contributing their data, and the accuracy of the data analysis results, inferring useful properties about the population. The compositional nature of differential privacy has motivated the design and implementation of several programming languages to ease the implementation of differentially private analyses. Even though these programming languages provide support for reasoning about privacy, most of them disregard reasoning about the accuracy of data analyses. To overcome this limitation, we present DPella, a programming framework providing data analysts with support for reasoning about privacy, accuracy, and their trade-offs. The distinguishing feature of DPella is a novel component that statically tracks the accuracy of different data analyses. To provide tight accuracy estimations, this component leverages taint analysis for automatically inferring statistical independence of the different noise quantities added for guaranteeing privacy. We evaluate our approach by implementing several classical queries from the literature and showing how data analysts can calibrate the privacy parameters to meet the accuracy requirements, and vice versa. [ABSTRACT FROM AUTHOR]

In this paper, we propose a framework capable of dealing with anaphora and ellipsis which is both general and algorithmic. This generality is ensured by the compination of two general ideas. First, we use a dynamic semantics which reperent effects using a monad structure. Second we treat scopes flexibly, extending them as needed. We additionally implement this framework as an algorithm which translates abstract syntax to logical formulas. We argue that this framework can provide a unified account of a large number of anaphoric phenomena. Specifically, we show its effectiveness in dealing with pronominal and VP-anaphora, strict and lazy pronouns, lazy identity, bound variable anaphora, e-type pronouns, and cataphora. This means that in particular we can handle complex cases like Bach–Peters sentences, which require an account dealing simultaneously with several phenomena. We use Haskell as a meta-language to present the theory, which also consitutes an implementation of all the phenomena discussed in the paper. To demonstrate coverage, we propose a test suite that can be used to evaluate computational approaches to anaphora. [ABSTRACT FROM AUTHOR]

When creating a programming language, it is necessary to determine its syntax and semantics. The main task of syntax is to describe all constructions that are elements of the language. For this purpose, a specific syntax highlights syntactically correct sequences of characters of the language alphabet. Most often it is a finite set of rules that generate an infinite set of all construction languages, such as the extended Backus- Naur (BNF) form. To describe the semantics of the language, the preference is given to the abstract syntax, which in real programming languages is shorter and more obvious than specific. The relationship between abstract syntax objects and the syntax of the program in compilers solves the parsing phase. Denotational semantics is used to describe semantics. Initially, it records the denotations of the simplest syntactic objects. Then, with each compound syntactic construction, a semantic function is associated, which by denotations of components of a design calculates its value - denotation. Since the program is a specific syntactic construction, its denotation is possible to determine using the appropriate semantic function. Note that the program itself is not executed when calculating its denotation. The denotative description of a programming language includes the abstract syntax of its constructions, denotations - the meanings of constructions and semantic functions that reflect elements of abstract syntax (language constructions) in their denotations (meanings). The use of the functional programming language Haskell as a metalanguage is considered. The Haskell type system is a good tool for constructing abstract syntax. The various possibilities for describing pure functions, which are often the denotations of programming language constructs, are the basis for the effective use of Haskell to describe denotational semantics. The paper provides a formal specification of a simple imperative programming language with integer data, block structure, and the traditional set of operators: assignment, input, output, loop and conditional. The ability of Haskell to effectively implement parsing, which solves the problem of linking a particular syntax with the abstract, allows to expand the formal specification of the language to its implementation: a pure function -- the interpreter. The work contains all the functions and data types that make up the interpreter of a simple imperative programming language. [ABSTRACT FROM AUTHOR]

The main objective of this study is to present and exemplify a computational solution to minimize the cost of designing curriculum plans by using bio-inspired algorithms to automate and reduce errors. The study focuses on solving the balanced academic curriculum problem (BACP) through metaheuristic optimization, based on the behavior or algorithm of fireflies and based on the use of functional programming in the Haskell language. The firefly algorithm is applied to a set of test instances to demonstrate its effectiveness. The results show that by applying the proposed solution function to optimize load balance in curricular meshes of eight, 10, and 12 semesters, the performance is oscillating when considering 50 runs. But, it permits obtaining expected values for the minimum academic load in each case. It is concluded that the proposal presented here allows generating efficient solutions for designing balanced curricular meshes. [ABSTRACT FROM AUTHOR]

Summary: Dynamic programming is a well‐known algorithmic technique that solves problems by a combination of dividing a problem into subproblems and using memoization to avoid an exponential growth of the costs. We show how to implement dynamic programming in Haskell using a variation of hylomorphisms that includes memoization. Our implementation uses polymorphism so the same function can return the best score or the solution to the problem based on the type of the returned value. [ABSTRACT FROM AUTHOR]

Este artículo corresponde a la segunda parte de un estudio donde se explora el ordenamiento de números difusos con miras a su uso en consultas a bases de datos. En la primera parte: se presentó una nueva propuesta que compara dos números difusos usando la abscisa del centroide; y se demostró que es una relación orden total. En esta segunda parte: se abordan casos de estudio que comprenden una vasta diversidad de posibles situaciones de comparación de números difusos con distintas representaciones; se presenta una implementación en Haskell del método propuesto; y se pone en evidencia su adecuación a la intuición humana.

A worthy cryptographic protocol specification has to be human-readable (declarative and concise), executable and formally verified in a sound model. Keeping in mind these requirements, we present a protocol message definition notation named CMN.1, which is based on an abstraction named cryptographic stack machine. The paper presents the syntax and semantics of CMN.1 and the principles of implementation of the CMN.1-based executable protocol specification language. The core language library (the engine) performs all the message processing, whereas a specification should only provide the declarative definitions of the messages. If an outcoming message must be formed, the engine takes the CMN.1 definition as input and produces the binary data in consistency with it. When an incoming message is received, the engine verifies the binary data with respect to the given CMN.1 definition memorizing all the information needed in the further actions. The verification is complete: the engine decrypts the ciphertexts, checks the message authentication codes and signatures, etc. Currently, the author's proof-of-concept implementation of the language (embedded in Haskell) can translate a CMN.1-based specifications both to the interoperable implementations and to the programs for the ProVerif protocol analyzer. The excerpts from the CMN.1-based TLS protocol specification and corresponding automatically generated ProVerif program are provided as an illustration.

Marlowe is a DSL for financial contracts. We describe the implementation of Marlowe on the Cardano blockchain, and the Marlowe Playground web-based development and simulation environment. Contracts in Marlowe can be exhaustively analysed prior to running them, thus providing strong guarantees to participants in the contract. The Marlowe system itself has been formally verified using the Isabelle theorem prover, establishing such properties as the conservation of money. [ABSTRACT FROM AUTHOR]

With the decline of Moore's law and the ever increasing availability of cheap massively parallel hardware, it becomes more and more important to embrace parallel programming methods to implement Agent-Based Simulations (ABS). This has been acknowledged in the field a while ago and numerous research on distributed parallel ABS exists, focusing primarily on Parallel Discrete Event Simulation as the underlying mechanism. However, these concepts and tools are inherently difficult to master and apply and often an excess in case implementers simply want to parallelise their own, custom agent-based model implementation. However, with the established programming languages in the field, Python, Java and C++, it is not easy to address the complexities of parallel programming due to unrestricted side effects and the intricacies of low-level locking semantics. Therefore, in this paper we propose the use of a lock-free approach to parallel ABS using Software Transactional Memory (STM) in conjunction with the pure functional programming language Haskell, which in combination, removes some of the problems and complexities of parallel implementations in imperative approaches. We present two case studies, in which we compare the performance of lock-based and lock-free STM implementations in two different well known Agent-Based Models, where we investigate both the scaling performance under increasing number of CPU cores and the scaling performance under increasing number of agents. We show that the lock-free STM implementations consistently outperform the lock-based ones and scale much better to increasing number of CPU cores both on local hardware and on Amazon EC. Further, by utilizing the pure functional language Haskell we gain the benefits of immutable data and lack of unrestricted side effects guaranteed at compile-time, making validation easier and leading to increased confidence in the correctness of an implementation, something of fundamental importance and benefit in parallel programming in general and scientific computing like ABS in particular. [ABSTRACT FROM AUTHOR]

Dennis Haskell's Rhonda poems are undoubtedly the most brilliant and important part of his poetry in the sense that he wrote passionately about love, death and memories in relation to Rhonda in them. As Haskell's wife and lifelong love, Rhonda not only played a central part in his life and writing, but shaped and deepened his perception of humanity and human relationships. Despite the great impact of Modernism on modern and contemporary English poetry, Haskell's poetry is strikingly personal, accessible and lyrical. In his work, Haskell seeks to present the approximately genuine pictures of aspects of human relationships in terms of love, death and memories and ultimately, strives to make sense of the dynamics of love in our mundane life. [ABSTRACT FROM AUTHOR]

Dennis Haskell's poetry persistently explores images of home and departure. As it does, it questions what we may know and depend on, suggesting that many of our understandings are provisional. Haskell's poetry also contrasts what is imagined and desired with what is knowable - giving prominence to quotidian knowledge and observable reality - and restlessly explores the relationship of religious belief to lived experience. In this light, the elegiac strand in his work becomes a way of probing the gap between death and the limitations of language, highlighting the sometimes problematic relationship between thought and expression. Yet, poetry provides a means of access to otherwise unapproachable thoughts and feelings and connects the poet (and reader) to an articulate human community. It enables the delineation of a simultaneously observant, detached and engaged subjectivity that consistently seeks to find connections - whether at home, while travelling or in international settings. This poetry joins the familiar and unfamiliar in works that question how people understand one another and their unique circumstances, and how the ineffable, while it may be evoked in words, nevertheless retains its deep mysteries. Haskell is interested in the ways in which we make and disturb meaning, and in questioning how belief in God or an afterlife may be understood despite scepticism and doubt. [ABSTRACT FROM AUTHOR]