An “executable” impredicative semantics for the Ada configuration

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

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

Standard ML is a strictly typed functional programming language that provides programmers with many powerful features, including parametric polymorphism, pattern matching, and a rich module system. In this paper, we present SMLtoJs, an optimizing compiler that compiles Standard ML programs into JavaScript to be executed in any JavaScript-supported Web browser. SMLtoJs supports all of Standard ML and most of the Standard ML Basis Library, which allows for the SMLtoJs compiler itself to be compiled and executed in a browser. We present the overall structure of SMLtoJs, including the non-JavaScript aware front-end and the JavaScript-specific backend. We also present SMLtoJs's type safe interface for interacting with native JavaScript, such as the DOM api. Finally, we present the details of the JavaScript-specific optimizations, including how SMLtoJs deals with tail recursion, which enable complex Standard ML programs to be compiled into efficient JavaScript.

To facilitate architecture development of largescale and complex systems, we have proposed an architecture engineering methodology and defined seven kernels of architecture engineering (i.e., opportunity, Stakeholder, Need, Architecture, Team, Work and Way-of-Working) which must be considered during the process of developing an architecture. Each kernel has five or six different states that can indicate the progress and health of architecture development. To further improve practicability of the defined seven kernels and their 36 states in architecture development, a reference guide is suggested based on our engineering experience in practice, which contains more than 100 items helping to check kernel states and move them forward. Using the reference guide, we conducted an application of architecture development of a complex business information system. Results show that the proposed guide can be effectively used to help architecture engineers to determine and push on the state of architecture development. Architecture development can be proceeded clearly, timely and smoothly. Moreover, all the team members can work well together.

Software models play a significant role with the growth of software system development based on Model Driven Development (MDD) approach. Model transformations and compositions are the heart of MDD and allow the development of complex systems and their automated derivation. Moreover, software development of large and complex systems uses a collection of models, where model composition and decomposition are required. Various research studies have been done on specifying and executing MDD processes; however only a few of those have considered the validity of such transformations, thus safe composition and decomposition of models. This paper presents a general approach for model composition for the transformation from UML sequence diagrams to Coloured Petri Nets and validates the correctness of model composition using a mathematical proof. These transformations are based on formal rules, which have already been proven to be strongly consistent.

Standard ML is a state of the art functional programming language, with features that make it excellent for teaching recursion and problem solving at the introductory level. Among the many pedagogically interesting characteristics of ML are its simple and uniform syntax, its type polymorphism and type inferencing system, and datatype declaration facilities. With little formal ML instruction, after several weeks first year students were able to use recursively defined data structures and to define fairly powerful recursive functions in ML. Standard ML is highly recommended as a tool for teaching recursive problem solving in the context of a course on the foundations of computer science.

Abstract. At a fundamental level, functional and object-oriented programming languages are all ‘higher-order’, in the sense that they support computing with values that are themselves pieces of program code encapsulated with a local environment. In functional languages these ‘active’ values are functions, while in object-oriented languages they are objects. Both styles of higher-order language claim to provide good support for writing adaptable programs, but functional and object-oriented languages achieve this adaptability in different ways: functional programs rely on parameterisation at the value, type and module level, while object-oriented languages rely primarily on subtyping and implementation inheritance. Here we compare these two approaches, mainly in terms of the features and properties of their type systems, and consider the benefits and disadvantages of unifying (or merging) the two paradigms by adding object-oriented features to ML as a base language. We argue that while some of the simpler aspects of object-oriented languages are compatible with ML, adding a full- edged class-based object system to ML leads to an excessively complex type system and relatively little expressive gain, especially if we aim to preserve that mostly functional style of programming that is a major advantage of ML.

The higher-order logic found in proof assistants such as Coq and various HOL systems provides a convenient setting for the development and verification of pure functional programs. However, to efficiently run these programs, they must be converted (or "extracted") to functional programs in a programming language such as ML or Haskell. With current techniques, this step, which must be trusted, relates similar looking objects that have very different semantic definitions, such as the set-theoretic model of a logic and the operational semantics of a programming language. In this paper, we show how to increase the trustworthiness of this step with an automated technique. Given a functional program expressed in higher-order logic, our technique provides the corresponding program for a functional language defined with an operational semantics, and it provides a mechanically checked theorem relating the two. This theorem can then be used to transfer verified properties of the logical function to the program. We have implemented our technique in the HOL4 theorem prover, translating functions to a core subset of Standard ML, and have applied it to examples including functional data structures, a parser generator, cryptographic algorithms, and a garbage collector.

An important feature of functional programs is that they are parallel by default. Implementing an efficient parallel functional language, however, is a major challenge, in part because the high rate of allocation and freeing associated with functional programs requires an efficient and scalable memory manager. In this paper, we present a technique for parallel memory management for strict functional languages with nested parallelism. At the highest level of abstraction, the approach consists of a technique to organize memory as a hierarchy of heaps, and an algorithm for performing automatic memory reclamation by taking advantage of a disentanglement property of parallel functional programs. More specifically, the idea is to assign to each parallel task its own heap in memory and organize the heaps in a hierarchy/tree that mirrors the hierarchy of tasks. We present a nested-parallel calculus that specifies hierarchical heaps and prove in this calculus a disentanglement property, which prohibits a task from accessing objects allocated by another task that might execute in parallel. Leveraging the disentanglement property, we present a garbage collection technique that can operate on any subtree in the memory hierarchy concurrently as other tasks (and/or other collections) proceed in parallel. We prove the safety of this collector by formalizing it in the context of our parallel calculus. In addition, we describe how the proposed techniques can be implemented on modern shared-memory machines and present a prototype implementation as an extension to MLton, a high-performance compiler for the Standard ML language. Finally, we evaluate the performance of this implementation on a number of parallel benchmarks.

In an impure functional language, there are programs whose behaviour is completely functional (in that they behave extensionally on inputs), but the functions they compute cannot be written in the purely functional fragment of the language. That is, the class of programs with functional behaviour is more expressive than the usual class of pure functional programs. In this paper we introduce this extended class of "functional" programs by means of examples in Standard ML, and explore what they might have to offer to programmers and language implementors.After reviewing some theoretical background, we present some examples of functions of the above kind, and discuss how they may be implemented. We then consider two possible programming applications for these functions: the implementation of a search algorithm, and an algorithm for exact real-number integration. We discuss the advantages and limitations of this style of programming relative to other approaches. We also consider the increased scope for compiler optimizations that these functions would offer.

Exploring the vulnerability characteristics of the economic-social-ecological complex system of island tourism destinations can provide better theoretical and practical guidance for the sustainable development of island tourism destinations. Taking Zhoushan, which is a famous island tourism destination in China, as a case, based on the vulnerability analysis framework of exposure, sensitivity, and adaptive capacity, this paper employs the entropy value method, comprehensive index method, system coordination degree model, and obstacle model to quantitatively measure the vulnerability of the economic-social-ecological complex system of Zhoushan from 2011 to 2022. It analyzes the spatial and temporal heterogeneity characteristics of the complex system`s vulnerability and the obstacle factors in the four administrative regions that make up the case site. The research results reveal that the vulnerability of Zhoushan’s economic-social-ecological complex system shows a decreasing trend, indicating its ability to withstand external disturbances continuously increases. However, the decline in the coordinated development of vulnerability reveals the imbalance in the development of internal systems among the four different regions. Furthermore, the study finds that the degree of obstacles to the ecological system is relatively high at the system level. In contrast, at the indicator level, the main obstacle factors are the total import and export trade, density of the tourism economy, construction land ratio, island land and sea area coefficient, and tourist density. Based on these findings, the study suggests deepening trans-regional cooperation, paying attention to constructing ecological systems and promoting the coordinated development of the island tourism destination complex system to reduce the overall vulnerability of island tourism destinations.

The type systems of most typed functional programming languages are based on the Hindley-Milner type system. A practical problem with these type systems is that it is often hard to understand why a program is not type correct or a function does not have the intended type. We suggest that at the core of this problem is the difficulty of explaining why a given expression has a certain type. The type system is not defined compositionally. We propose to explain types using a variant of the Hindley-Milner type system that defines a compositional type explanation graph of principal typing. We describe how the programmer understands types by interactive navigation through the explanation graph. Furthermore, the explanation graph can be the foundation for algorithmic debugging of type errors, that is, semi-automatic localisation of the source of a type error without even having to understand the type inference steps. We implemented a prototype of a tool to explore the usefulness of the proposed methods.

In this paper we present a language for programming with higher-order modules. The language HML is based on Standard ML in that it provides structures, signatures and functors. In HML, functors can be declared inside structures and specified inside signatures; this is not possible in Standard ML. We present an operational semantics for the static semantics of HML signature expressions, with particular emphasis on the handling of sharing. As a justification for the semantics, we prove a theorem about the existence of principal signatures. This result is closely related to the existence of principal type schemes for functional programming languages with polymorphism.

We present a novel counterexample generator for the interactive theorem prover Isabelle based on a compiler that synthesizes test data generators for functional programming languages (e.g. Standard ML, OCaml) from specifications in Isabelle. In contrast to naive type-based test data generators, the smart generators take the preconditions into account and only generate tests that fulfill the preconditions. The smart generators are constructed by a compiler that reformulates the preconditions as logic programs and analyzes them by an enriched mode inference. From this inference, the compiler can construct the desired generators in the functional programming language. These test data generators are applied to find errors in specifications, as we show in a case study of a hotel key card system.

A trend towards the provision of product-service packaging and the proliferation of service businesses introduces both tangible and intangible elements into system design. In this paper, we consider the utility of hierarchical system models as a way of flexibly combining such elements by focusing on requisite functionality. Four cases illustrate how the same approach may be used to clarify the requirements of business or socio-technical systems during system development, operation or reengineering stages. It is suggested that a suitable loosely coupled model has significant utility as a 'boundary object' - a term first coined in the study of museum artefacts. Discussion of such objects requires the use of imagination, which may support innovative system design and development. It is suggested that a well-crafted model has multiple uses - as a foundation for system development, in combining traditional and agile project management strategies and in providing a framework to facilitate the capture and organisation of project knowledge.