the 19thacmsigplaninternationalconference on functionalprogramming (ICFP) took place on September 1–3, 2014 in Gothenburg, Sweden. After the conference, the programme committee, chaired by Manuel Chakravarty, se...
the 19thacmsigplaninternationalconference on functionalprogramming (ICFP) took place on September 1–3, 2014 in Gothenburg, Sweden. After the conference, the programme committee, chaired by Manuel Chakravarty, selected several outstanding papers and invited their authors to submit to this special issue of JFP. We acted as editors for these submissions. this issue includes the six accepted papers, each of which provides substantial new material beyond the original conference version. the selected papers demonstrate boththe quality and the breadth of the conference, with a strong emphasis on types and their applications, and ranging from compilation methods through contract verification to homotopy type theory.
We present a new interface for practical functional Reactive programming (FRP) that (1) is close in spirit to the original FRP ideas, (2) does not have the original space-leak problems, without using arrows or advance...
详细信息
ISBN:
(纸本)9781450336697
We present a new interface for practical functional Reactive programming (FRP) that (1) is close in spirit to the original FRP ideas, (2) does not have the original space-leak problems, without using arrows or advanced types, and (3) provides a simple and expressive way for performing I/O actions from FRP code. We also provide a denotational semantics for this new interface, and a technique (using Kripke logical relations) for reasoning about which FRP functions may "forget their past", i.e. which functions do not have an inherent space-leak. Finally, we show how we have implemented this interface as a Haskell library called FRPNow.
this paper proposes a design-driven development approach that is dedicated to the domain of orchestration of masses of sensors. the developer declares what an application does using a domain-specific language (DSL). O...
详细信息
ISBN:
(纸本)9781450336871
this paper proposes a design-driven development approach that is dedicated to the domain of orchestration of masses of sensors. the developer declares what an application does using a domain-specific language (DSL). Our compiler processes domain-specific declarations to generate a customized programming framework that guides and supports the programming phase.
We present the design and implementation of a SQL query processor that outperforms existing database systems and is written in just about 500 lines of Scala code - a convincing case study that high-level functional pr...
详细信息
ISBN:
(纸本)9781450336697
We present the design and implementation of a SQL query processor that outperforms existing database systems and is written in just about 500 lines of Scala code - a convincing case study that high-level functionalprogramming can handily beat C for systems-level programming where the last drop of performance matters. the key enabler is a shift in perspective towards generative programming. the core of the query engine is an interpreter for relational algebra operations, written in Scala. Using the open-source LMS Framework (Lightweight Modular Staging), we turn this interpreter into a query compiler with very low effort. To do so, we capitalize on an old and widely known result from partial evaluation known as Futamura projections, which state that a program that can specialize an interpreter to any given input program is equivalent to a compiler. In this pearl, we discuss LMS programming patterns such as mixed-stage data structures (e.g. data records with static schema and dynamic field components) and techniques to generate low-level C code, including specialized data structures and data loading primitives.
High-level scripting languages have become tremendously popular for development of dynamic Web applications. Many programmers appreciate the productivity benefits of automatic storage management, freedom from verbose ...
详细信息
ISBN:
(纸本)9781450336697
High-level scripting languages have become tremendously popular for development of dynamic Web applications. Many programmers appreciate the productivity benefits of automatic storage management, freedom from verbose type annotations, and so on. While it is often possible to improve performance substantially by rewriting an application in C or a similar language, very few programmers bother to do so, because of the consequences for human development effort. this paper describes a compiler that makes it possible to have most of the best of both worlds, coding Web applications in a high-level language but compiling to native code with performance comparable to handwritten C code. the source language is Ur/Web, a domain-specific, purely functional, statically typed language for the Web. through a coordinated suite of relatively straightforward program analyses and algebraic optimizations, we transform Ur/Web programs into almost-idiomatic C code, with no garbage collection, little unnecessary memory allocation for intermediate values, etc. Our compiler is in production use for commercial Web sites supporting thousands of users, and microbenchmarks demonstrate very competitive performance versus mainstream tools.
Heterogeneous programming complicates software development. We present CLOP, a platform that embeds code targeting heterogeneous compute devices in a convenient and clean way, allowing unobstructed data flow between t...
详细信息
ISBN:
(纸本)9781450336871
Heterogeneous programming complicates software development. We present CLOP, a platform that embeds code targeting heterogeneous compute devices in a convenient and clean way, allowing unobstructed data flow between the host code and the devices, reducing the amount of source code by an order of magnitude. the CLOP compiler uses the standard facilities of the D programming language to generate code strictly at compile-time. In this paper we describe the CLOP language and the CLOP compiler implementation.
Using GPUs as general-purpose processors has revolutionized parallel computing by offering, for a large and growing set of algorithms, massive data-parallelization on desktop machines. An obstacle to widespread adopti...
详细信息
ISBN:
(纸本)9781450336871
Using GPUs as general-purpose processors has revolutionized parallel computing by offering, for a large and growing set of algorithms, massive data-parallelization on desktop machines. An obstacle to widespread adoption, however, is the difficulty of programmingthem and the low-level control of the hardware required to achieve good performance. this paper suggests a programming library, SafeGPU, that aims at striking a balance between programmer productivity and performance, by making GPU data-parallel operations accessible from within a classical object-oriented programming language. the solution is integrated withthe design-by-contract approach, which increases confidence in functional program correctness by embedding executable program specifications into the program text. We show that our library leads to modular and maintainable code that is accessible to GPGPU non-experts, while providing performance that is comparable with hand-written CUDA code. Furthermore, runtime contract checking turns out to be feasible, as the contracts can be executed on the GPU.
Software Defined Networking (SDN) programs are written with respect to assumptions on software and hardware facilities and protocol definitions. Silent mismatches between the expected feature set and implemented featu...
详细信息
ISBN:
(纸本)9781450336871
Software Defined Networking (SDN) programs are written with respect to assumptions on software and hardware facilities and protocol definitions. Silent mismatches between the expected feature set and implemented feature set of SDN artifacts can easily lead to hard to debug network configurations, decreased network performance, outages, or worse, security vulnerabilities. We show how the paradigm of axiomatic programming, supported by practical dependent types, provides effective support for SDN executable specifications and verification.
Internet of things (IoT) application development is technically challenging and complex due to several factors such as the presence of different IoT protocols, interoperability issues, lack of industry standards and d...
详细信息
Internet of things (IoT) application development is technically challenging and complex due to several factors such as the presence of different IoT protocols, interoperability issues, lack of industry standards and dealing withthe heterogeneity that exists both in Physical and Internet worlds. Furthermore, developers involved in the IoT application development have to address issues pertaining to different life-cycles ranging from design, implementation to deployment (deployment complexities due to the possibilities of wide range of devices). Manual effort involved in all above three phases for heterogeneous devices is a time-consuming and error-prone process. We demonstrate IoTSuite which is an application development platform consisting of a suite of tools motivated by the need to simplify IoT application development. the IoTSuite supports several features such as automatic code generation and integration with a set of modeling languages. It takes high-level specification as input that abstract heterogeneity related complexity. It integrates compiler and deployment module to provide automation at different phases of application development process.
Higher order functions provide an elegant way to express algorithms designed for implementation in hardware [1, 6-9]. By showing examples of both classic and new algorithms, I will explain why higher order functions d...
详细信息
ISBN:
(纸本)9781450336697
Higher order functions provide an elegant way to express algorithms designed for implementation in hardware [1, 6-9]. By showing examples of both classic and new algorithms, I will explain why higher order functions deserve to be studied. Next, I will consider the extent to which ideas from functionalprogramming, and associated formal verification methods, have influenced hardware design in practice [3-5, 10]. What can we learn from looking back? You might ask "Why are methods of hardware design still important to our community?". Maybe we should just give up? One reason for not giving up is that hardware design is really a form of parallel programming. And here there is still a lot to do! Inspired by Blelloch's wonderful invited talk at ICFP 2010 [2], I still believe that functionalprogramming has much to offer in the central question of how to program the parallel machines of today, and, more particularly, of the future. I will briefly present some of the areas where I think that we are poised to make great contributions. But maybe we need to work harder on getting our act together?
暂无评论