Table of Contents

Poster: the development of a semantic feature analysis based mobile application for individuals with aphasia

Professional JavaScript for Web Developers

Functional Programming and the Lambda Calculus

Stephen A. Edwards Columbia University Fall 2008

The Lambda Calculus, Its Syntax and Semantics

λ-Calculus: Then & Now

Dana S. Scott University Professor Emeritus Carnegie Mellon University Visiting Scholar University of California, Berkeley

A Useful λ-Notation

KAMAREDDINE, F. AND NEDERPELT, R. 1996b. A useful λ-notation. Theoretical Comput. Sci. 155, 1, 85–109. KLEENE, S

An historical survey on type theory can be found in Kamareddine et al.

The formal system λδ

An Interpreter for Extended Lambda Calculus

AI Memo No. 349, December 1979


This brings up the point that the pedagogy of programming languages shouldn't start with the mathematical foundations: that battle has largely been lost in spite of the typing and proof approaches. It would be better to create something fun, play with the current best language available, then move to something more historical.

For example,

Would probably be best not to require that one conform directly to typing the language: though generally something that wouldn't be advised the building block approach might be reasonable.

DONE Testable JavaScript

Starts just by looking at the reasons by one would want to test their code: that's not a particularly good use of time since people buying the book presumeably understand the goals.

Looks initially just at the process for software development; likely a previous job from Mark Trostler?

Covered some interesting points:

The Road to Modern Logic - An Interpretation

The Completion of the Emergence of Modern Logic

… from Boole’s The Mathematical Analysis of Logic to Frege’s Begriffsschrift

The Org Mode 7 Reference Manual


  • Using C-c = for adding calculations

TODO Keywords for org-mode

Using TODO as the main keyword with the default state changes.

Should review the progress logging notes in 5.3 later this evening

org-export-with-todo-keywords is a variable defined in `org-exp.el'.

Dates and Times

  • Using scheduled dates more agressively


  • Using base capture templates
  • Added emacsclient


  • Adding new org-agenda-files
  • Custom agenda views for week and status


  • Base setup to WebDav
  • Separating of notes to SVN directory but shared WebDav
  • org-mobile-push org-mobile-push on startup
  • Setup of iOS

Easy Templates

  • <e <s examples
  • This are covered more fully in 16.2

A Simpler Proof Theory for Nominal Logic

equivariance, freshness and abstraction.

Equivariance and Invariance

Definition. A group G is a nonempty set G together with a binary operation ◦ such that

• g1,g2 ∈ G ⇒ g1 ◦ g2 ∈ G (closure); • ∃e ∈ G ∀g ∈ G, e ◦ g = g (identity); • ∀g ∈ G ∃g −1 ∈ G 3 g −1 ◦ g = e (inverse); • g1,g2,g3∈ G ⇒ g 1 ◦ (g2 ◦ g3) = (g1 ◦ g2) ◦ g3 (associativity).

Higher-Order Abstract Syntax: Setting the Record Straight

Nominal logic, a first order theory of names and binding

Nominal Logic Programming

The primary book for the programming side of the course is Learn Prolog Now, by Blackburn, Bos and Striegnitz. The book is strongly recommended, and is available free on-line. Other useful books on prolog programming are

Programming in Prolog by Clocksin and Mellish, Springer. (There are many copies of this in the University library.) The Art of Prolog by Sterling and Shapiro, MIT Press Prolog Programming for Artificial Intelligence by Ivan Bratko, Addison Wesley. For the theory lectures, the following background material on propositional and predicate will be useful for students who have not previously encountered propositional and predicate logic.

Wikipedia page on Propositional calculus Wikipedia page on First-order logic Wikipedia page on Structure (mathematical logic) Introductory slides (pdf) on Predicate logic and quantifiers from University of Nebraska

First-Order Logic

  title={First-Order Logic},
  author={Smullyan, R.M.},
  series={Erg. d. Math. u. i. Grenzgeb},
  publisher={Springer Berlin Heidelberg}

Learn Prolog Now!

AdSentry: comprehensive and flexible confinement of JavaScript-based advertisements

An Introduction to Functional Programming through Lambda Calculus

This was also listed under which looks interesting.

Core concepts

Seems so much harder than the actual concepts being applied: the semantics of lambda calculus makes it more annoying and makes the value suspects for practitioners.

ToMaTo: a trustworthy code mashup development tool

An empirical study of privacy-violating information flows in JavaScript web applications

Partitioning graphs to speedup Dijkstra's algorithm

Purely functional data structures

Russellian Simple Type Theory

Alonzo Church Proceedings and Addresses of the American Philosophical Association Vol. 47, (1973 - 1974), pp. 21-33 Published by: American Philosophical Association Article Stable URL:

Learn You a Haskell

Tree-Manipulating Systems and Church-Rosser Theorems SERVICE&CFID=197161644&CFTOKEN=63442998&__acm__=1364320374_27f40ba8627d0a8be785bcbf0431e82c

The functional power of parameter passage mechanism

Learning from the Web

On the security of public-key protocols

HTTP Cookies: Standards, privacy, and politics

Web caching on smartphones: ideal vs. reality

Selecting a hashing algorithm

JavaScript as an embedded DSL

How not to survey developers and repositories: experiences analyzing language adoption

The Joy of Clojure: Thinking the Clojure Way   clojure

On Kindle.

Programming Clojure   clojure

EMACS the extensible, customizable self-documenting display editor

Eoops: an object-oriented programming system for Emacs-Lisp

Multics Emacs (Prose and Cons): A commercial text-processing system in Lisp

Mixin-based inheritance

XSLT version 2.0 is turing-complete: a purely transformation based proof

Javascript bible, sixth edition   javascript

Status report: specifying JavaScript with ML

ECMA-262: ECMAScript Language Specification   javascript

10 Immutable Laws of Security

Graded Browser Support

The Promise System

Channels: A Generalization of Streams

Promises: Linguistic Support for Efficient Asynchronous Procedure Calls in Distributed Systems

Async JavaScript: Build More Responsive Apps with Less Code

You purchased this item on July 13, 2012.

The Uses of Knowledge in Society

A Universal Modular ACTOR Formalism for Artificial Intelligence

Design Patterns, Elements Of Reusable Object-Oriented Software

A Security Kernel Based on the Lambda-Calculus

The Architecture of Complexity

Measuring Relative Attack Surfaces

Toward a Critical Theory of Cyberspace

Hedgehog Architecture

DONE Tracking the trackers: fast and scalable dynamic analysis of web content for privacy violations

This had a number of the same points that we were planning on using for the fingerprinting.

Each of the parameters we were passing were going to be included in the list of privacy affected components.

TODO I Still Know What You Visited Last Summer: Leaking Browsing History via User Interaction and Side Channel Attacks

TODO An empirical study of privacy-violating information flows in JavaScript web applications   privacy javascript

 author = {Jang, Dongseok and Jhala, Ranjit and Lerner, Sorin and Shacham, Hovav},
 title = {An empirical study of privacy-violating information flows in JavaScript web applications},
 booktitle = {Proceedings of the 17th ACM conference on Computer and communications security},
 series = {CCS '10},
 year = {2010},
 isbn = {978-1-4503-0245-6},
 location = {Chicago, Illinois, USA},
 pages = {270--283},
 numpages = {14},
 url = {},
 doi = {10.1145/1866307.1866339},
 acmid = {1866339},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {JavaScript, dynamic analysis, history sniffing, information flow, privacy, rewriting, web application, web security},
var l = document.getElementsByTagName('a')[0];
document.defaultView.getComputedStyle(l, null).getPropertyValue("color")

TODO Privacy leakage in mobile online social networks

Figure 3 shows three different mOSN interfaces where the mOSN identifier is leaked to a third-party server as part of a HTTP request via either the Request-URI or the Referer header.

AOJS: aspect-oriented javascript programming framework for web development

JavaScript is a popular scripting language that is particularly useful for client-side programming together with HTML /XML on the Web. As JavaScript programs become more complex and large, separation of concerns at the implementation level is a significant challenge.

Keeping information safe from social networking apps

Privacy-aware identity management for client-side mashup applications

Web user de-identification in personalization

AjaxScope: A Platform for Remotely Monitoring the Client-Side Behavior of Web 2.0 Applications

Formal specification of a JavaScript module system

An approach for identifying JavaScript-loaded advertisements through static program analysis

Similarly, return [expression,…]; was more common in ad-related scripts.

The case for JavaScript transactions: position paper

TODO Automated Analysis of Security-Critical JavaScript APIs   javascript

When browsing leaves footprints: automatically detect privacy violations

 author = {Hofinger, Hans and Kiening, Alexander and Schoo, Peter},
 title = {When browsing leaves footprints: automatically detect privacy violations},
 booktitle = {Proceedings of the First Workshop on Measurement, Privacy, and Mobility},
 series = {MPM '12},
 year = {2012},
 isbn = {978-1-4503-1163-2},
 location = {Bern, Switzerland},
 pages = {9:1--9:6},
 articleno = {9},
 numpages = {6},
 url = {},
 doi = {10.1145/2181196.2181205},
 acmid = {2181205},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {Firefox add-on, PRIVIDOR, privacy violations, web},

App isolation: get the security of multiple browsers with just one

 author = {Chen, Eric Yawei and Bau, Jason and Reis, Charles and Barth, Adam and Jackson, Collin},
 title = {App isolation: get the security of multiple browsers with just one},
 booktitle = {Proceedings of the 18th ACM conference on Computer and communications security},
 series = {CCS '11},
 year = {2011},
 isbn = {978-1-4503-0948-6},
 location = {Chicago, Illinois, USA},
 pages = {227--238},
 numpages = {12},
 url = {},
 doi = {10.1145/2046707.2046734},
 acmid = {2046734},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {cross-site request forgery, cross-site scripting, isolation, security modeling, web application security, web browser architecture},

AdSentry: Comprehensive and Flexible Confinement of JavaScript-based Advertisements

DONE Fast, Scalable Detection of “Piggybacked” Mobile Applications

Malware Family Module Name # Piggybacked Apps
Geinimi om.geinimi 6
Pjapps 8
DDream 10
BgServ 1

The open-closed principle

 author = {Martin, Robert C.},
 chapter = {The open-closed principle},
 title = {More C++ gems},
 editor = {Martin, Robert C.},
 year = {2000},
 isbn = {0-521-78618-5},
 pages = {97--112},
 numpages = {16},
 url = {},
 acmid = {331143},
 publisher = {Cambridge University Press},
 address = {New York, NY, USA},

Listed in

Realizing the Open-Closed Principle

The first principle in developing large software systems is the Open-Closed Principle (OCP). This principle seems asking for two conflict goals. How to realize the principle in the real software practice? What are the enabling technologies that can be used to implement the principle? This paper uses a case study to demonstrate the importance of the principle, the design methodology for realizing the principle, and its enabling technologies.

 author = {Xu, Chong-wei and Hughes, Jose},
 title = {Realizing the Open-Closed Principle},
 booktitle = {Proceedings of the Fourth Annual ACIS International Conference on Computer and Information Science},
 series = {ICIS '05},
 year = {2005},
 isbn = {0-7695-2296-3},
 pages = {274--279},
 numpages = {6},
 url = {},
 doi = {10.1109/ICIS.2005.107},
 acmid = {1091578},
 publisher = {IEEE Computer Society},
 address = {Washington, DC, USA},
 keywords = {Component-based Software Engineering, Software Reuse, Software Architecture, JavaBeans, Multithreading},

JavaScript: The Good Parts   javascript

JavaScript: The Definitive Guide   javascript

Third-Party Javascript   javascript

Looked at the delivery of JavaScript to make it non-blocking. The key notes are in

TODO Subdomain proxies

This should be reviewed more deeply.

Third-party cookies

See the table here for the best background on the behavior:

Browser Send Write Disabled by default
Chrome No No No
Firefox No No No
IE Yes No No
Opera Yes No No
Safari (+mobile) Yes Sometimes Yes

This also includes the prototype that lists how to test for the setting of third-party cookies.

This also recommended explicitly opening a new browser window as the way to force first-party status (p. 141).

Maintainable JavaScript   javascript

Programming JavaScript Applications

Picked up during the Fluent sale.

Chapter 5. Modules

This seems to have the best discussion of modules.

Not clear why they needed the specialized, independent, decomposable, recomposable, substitutable distinction as a "Principle of Modularity" rather than just diving in to the implementation aspects.

The Open Closed Principle states that a module interface should be open to extension but closed to modification.

This also had some of the information on how to best use browserify to creae a public application. This required setting a package.json. In general it looks like people will be moving away from RequireJS because of the complexity: even the async parts didn't seem to be that great and the masking of globals can be a bit difficult to debug.

Upgrading to RequireJS 2.1

Design Patterns

Program to an interface, not an implementation.

(quoted in )

JavaScript Enlightenment

Test-Driven JavaScript Development   javascript

JavaScript Patterns   javascript

Secrets of the Javascript Ninja   javascript

Eloquent JavaScript: A Modern Introduction to Programming   javascript

Dependent Types for JavaScript   javascript

We present Dependent JavaScript (DJS), a statically typed dialect of the imperative, object-oriented, dynamic language. DJS supports the particularly challenging features such as run-time type-tests, higher-order functions, extensible ob- jects, prototype inheritance, and arrays through a combina- tion of nested refinement types, strong updates to the heap, and heap unrolling to precisely track prototype hierarchies.

 author = {Chugh, Ravi and Herman, David and Jhala, Ranjit},
 title = {Dependent types for JavaScript},
 journal = {SIGPLAN Not.},
 issue_date = {October 2012},
 volume = {47},
 number = {10},
 month = oct,
 year = {2012},
 issn = {0362-1340},
 pages = {587--606},
 numpages = {20},
 url = {},
 doi = {10.1145/2398857.2384659},
 acmid = {2384659},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {JavaScript, arrays, prototype inheritance, refinement types, strong updates},

Type Analysis for JavaScript   javascript

JavaScript is the main scripting language for Web browsers, and it is essential to modern Web applications. Programmers have started using it for writing complex applications, but there is still little tool support available during development.

We present a static program analysis infrastructure that can infer detailed and sound type information for JavaScript programs using abstract interpretation. The analysis is designed to support the full language as defined in the ECMAScript standard, including its peculiar object model and all built-in functions. The analysis results can be used to detect common programming errors — or rather, prove their absence, and for producing type information for program comprehension.

 author = {Jensen, Simon Holm and M{\o}ller, Anders and Thiemann, Peter},
 title = {Type Analysis for JavaScript},
 booktitle = {Proceedings of the 16th International Symposium on Static Analysis},
 series = {SAS '09},
 year = {2009},
 isbn = {978-3-642-03236-3},
 location = {Los Angeles, CA},
 pages = {238--255},
 numpages = {18},
 url = {},
 doi = {10.1007/978-3-642-03237-0_17},
 acmid = {1615460},
 publisher = {Springer-Verlag},
 address = {Berlin, Heidelberg},

Even Faster Web Sites: Performance Best Practices for Web Developers   javascript

 author = {Souders, Steve},
 title = {Even Faster Web Sites: Performance Best Practices for Web Developers},
 year = {2009},
 isbn = {0596522304, 9780596522308},
 edition = {1st},
 publisher = {O'Reilly Media, Inc.},

This provides the core decision tree that is generally used when selecting loader. Applied heavily with some of the Canvas work but focussed more heavily when integrating with third-parties. See chapter 4 for the main distriction.

XHR Eval XHR Injection Script in Iframe Script DOM Elemnt Script Defer

In general for third-party JavaScript I've been looking at providing the no-order, async approach.

The Dispossessed

Contrast other books that note that the language used defines the ability to create abstractions.

  title={The Dispossessed},
  author={Guin, U.K.L.},


Windup Girl

South of the Border, West of the Sun



Evolution of Cooperation

Beyond the Hoax

Clojue Data Analysis Cookbook   clojure



Vision of Buddhism

Facets of Buddhism

Tao is Silent

Painted Birds


Tractatus Logico-Philophicus

Rissa and Tregare

Young Rissa

Programming in Scala

GNU Emacs Extensions


This Perfect Day

Best Writing on Mathematics 2012

HTML5 for Publishers

ClojureScript: Up and Running   clojure

Clojure in Action

From the Teeth of Angels

American Psycho

Day of the Triffids

Slaughterhouse - Five



Signal and the Noise

Effective JavaScript   javascript

Irony of American History

Fire Upon the Deep

Understanding Power

Prague Cemetery

Infinite Jest

Doing Capitalism in the Innovation Economy

The Great Thoughts

Well-Grouynded Rubyist

Rails 3 in Action   rails

Rails 4 in Action   rails

Age of Insight

Social Conquest of Earth

JavaScript Web Applications   javascript

Large Web Applications   javascript

Kafka on the Shore

Speaker for the Dead

Thinking Fast and Slow

Think Complexity



Functional Programming in Scala

Linked Data

Do Androids Dream of Electric Sheep?

A Scanner Darkly

Thinking Statistically

Programming Problems

Ender's Shadow

Reasoned Schemer

  title={The reasoned schemer},
  author={Friedman, D.P. and Byrd, W.E. and Kiselyov, O.},
  publisher={MIT Press}

RFC 6265: HTTP State Management Mechanism

Look at all of the fields available. Should there be an override?

Should there be encoding

Should this just be extra values.


Norwegian Wood

Woman in the Dunes


Brothers Karamozov


During an interstellar war one side develops a language, Babel-17, that can be used as a weapon. Learning it turns one into an unwilling traitor as it alters perception and thought. The change is made more dangerous by the language's seductive enhancement of other abilities.

Snow Crash



Count Zero

Mona Lisa Overdrive

Patern Recognition

Viral marketing with anonymous artistic clips.

Spook country

Zero History

The VAL Language: Description and Analysis

 author = {McGraw, James R.},
 title = {The VAL Language: Description and Analysis},
 journal = {ACM Trans. Program. Lang. Syst.},
 issue_date = {Jan. 1982},
 volume = {4},
 number = {1},
 month = jan,
 year = {1982},
 issn = {0164-0925},
 pages = {44--82},
 numpages = {39},
 url = {},
 doi = {10.1145/357153.357157},
 acmid = {357157},
 publisher = {ACM},
 address = {New York, NY, USA},

Coproducts of Monads on Set

Extending Monads with Pattern Matching

Monads, Zippers and Views

We make monadic components more reusable and robust to changes by employing two new techniques for virtualizing the monad stack: the monad zipper and monad views. The monad zipper is a higherorder monad transformer that creates virtual monad stacks by ignoring particular layers in a concrete stack. Monad views provide a general framework for monad stack virtualization: they take the monad zipper one step further and integrate it with a wide range of other virtualizations. For instance, particular views allow restricted access to monads in the stack. Furthermore, monad views provide components with a call-by-reference-like mechanism for accessing particular layers of the monad stack.

Monads in Action

In functional programming, monadic characterizations of computational effects are normally understood denotationally: they describe how an effectful program can be systematically expanded or translated into a larger, pure program, which can then be evaluated according to an effect-free semantics. Any effect-specific operations expressible in the monad are also given purely functional definitions, but these definitions are only directly executable in the context of an already translated program. This approach thus takes an inherently Church-style view of effects: the nominal meaning of every effectful term in the program depends crucially on its type.

Taming Aspects with Monads and Membranes

In this paper we describe how to control aspect interference by construction by relying on the type system. More precisely, we combine a monadic embedding of the pointcut/advice model in Haskell with the notion of membranes for aspect-oriented programming. Aspects must explicitly declare the side effects and the context they can act upon. Allowed patterns of control flow interference are declared at the membrane level and statically enforced. Finally, computational interference between aspects is controlled by the membrane topology. To combine independent and reusable aspects and monadic components into a program specification we use monad views, a recent technique for conveniently handling the monadic stack.

Towards Control of Aspect Interference using Membranes and Monads

In aspect-oriented programming (AOP), aspects are modular units that encapsulate crosscutting concerns. Aspects are typically developed independently, sometimes under the assumption that no other aspects will be applied to a system. However, when several aspects are applied on a system it is important to be aware of the interactions between them, because the correctness of the composed system may be affected.

Monads for Incremental Computing

This paper presents a monadic approach to incremental computation, suitable for purely functional languages such as Haskell. A program that uses incremental computation is able to perform an incremental amount of computation to accommodate for changes in input data. Recently, Acar, Blelloch and Harper presented a small Standard ML library that supports efficient, high-level incremental computations. Here, we present a monadic variant of that library, written in Haskell extended with first-class references. By using monads, not only are we able to provide a purely functional interface to the library, the types also enforce “correct usage” without having to resort to any type-system extension. We also find optimization opportunities based on standard monadic combinators.

The marriage of effects and monads

Abstract Gifford and others proposed an effect typing discipline to de- limit the scope of computational effects within a program, while Moggi and others proposed monads for much the same purpose. Here we marry effects to monads, uniting two pre- viously separate lines of research. In particular, we show that the type, region, and effect system of Talpin and Jou- velot carries over directly to an analogous system for mon- ads, including a type and effect reconstruction algorithm. The same technique should allow one to transpose any ef- fect systems into a corresponding monad system.

Building Interpreters by Composing Monads

Making Monads First-class with Template Haskell

Monad Transformers Step by Step

Monad Transformers Step by Step

The Marriage of Effects and Monads

Programming Monads Operationally with Unimo

Monads are widely used in Haskell for modeling computational effects, but defining monads remains a daunting challenge. Since every part of a monad’s definition depends on its computational effects, programmers cannot leverage the common behavior of all monads easily and thus must build from scratch each monad that models a new computational effect.

High Performance Websites

This was from an article

Load scripts without blocking. As described in rule 6, external scripts block the download and rendering of other content in the page. This is true when the script is loaded in the typical way: <script src=”foo.js” type=”text/javascript”></script> Several techniques for downloading scripts, however, avoid this blocking behavior: • XHR eval • XHR injection • script in iframe • script DOM element • script defer • document.write script tag You can see these techniques illustrated in Cuzillion (, but as an example let’s look at the script DOM element approach: <script type=”text/javascript”> var se = document.createElement(‘script’); se.src = ‘’; document.getElementsByTagName(‘head’). appendChild(se); </script>

Using types as search keys in function libraries

 author = {Rittri, Mikael},
 title = {Using types as search keys in function libraries},
 booktitle = {Proceedings of the fourth international conference on Functional programming languages and computer architecture},
 series = {FPCA '89},
 year = {1989},
 isbn = {0-89791-328-0},
 location = {Imperial College, London, United Kingdom},
 pages = {174--183},
 numpages = {10},
 url = {},
 doi = {10.1145/99370.99384},
 acmid = {99384},
 publisher = {ACM},
 address = {New York, NY, USA},

A method is proposed to search for an identifier by using its type as a key. This can be seen as an approximation of using the specification as a key. Functions that only differ in their currying or argument order are essentially the same, which is expressed by a con- gruence relation on types. Isomorphism in Cartesian closed categories is used for this purpose. Simpler put, types are re- garded as congruent if they are equal under an arithmetical interpretation, with Cartesian product as multiplication and function space as exponentiation. The congruence is char- acterized by seven axioms, and there is an efficient decision algorithm. A search system for Lazy ML has been implemented; its performance is promising

Retrieving re-usable software components by polymorphic type

 author = {Runciman, Colin and Toyn, Ian},
 title = {Retrieving re-usable software components by polymorphic type},
 booktitle = {Proceedings of the fourth international conference on Functional programming languages and computer architecture},
 series = {FPCA '89},
 year = {1989},
 isbn = {0-89791-328-0},
 location = {Imperial College, London, United Kingdom},
 pages = {166--173},
 numpages = {8},
 url = {},
 doi = {10.1145/99370.99383},
 acmid = {99383},
 publisher = {ACM},
 address = {New York, NY, USA},

ABSTRACT Polymorphic types are labels classifying both (a) degned components in a library and @) contexts of free variables in partially written programs. We propose to help programmers make better use of software libraries by providing a system that, given (b). identifies candidates from (a) with matching types. Assuming at first that matching means unifying (ie having a common instance) we discuss efficient ways of implementing such a retrieval system, and also indicate its likely effectiveness based on a quantitative study of currently available libraries. Later we introduce the applicative inamnce relation between types* which captures some iUttlitiOnS about generalisation/specialisation~ and discuss its use as the basis of a more flexible system.

On Lisp

On Lisp Prolog interpretter


Mentioned at #lambdajam


See also

Paradigms of Artificial Intelligence Programming

Push-pull functional reactive programming

@InProceedings {Elliott2009-push-pull-frp,
  author    = {Conal Elliott},
  title     = {Push-pull functional reactive programming},
  booktitle = {Haskell Symposium},
  url       = {},
  year      = 2009

Functional reactive programming (FRP) has simple and powerful semantics, but has resisted efficient implementation. In particular, most past implementations have used demand-driven sampling, which accommodates FRP’s continuous time semantics and fits well with the nature of functional programming. Consequently, values are wastefully recomputed even when inputs don’t change, and reaction latency can be as high as the sampling period.

Denotational design with type class morphisms

Functional Reactive Animation

  title        = {Functional Reactive Animation},
  url          = {},
  author       = "Conal Elliott and Paul Hudak",
  booktitle    = "International Conference on Functional Programming",
  year         = 1997

Two Techniques for Compiling Lazy Pattern Matching

    author = {Luc Maranget and Inria Rocquencort},
    title = {Two Techniques for Compiling Lazy Pattern Matching},
    year = {1994}

Lectures on the Curry-Howard Isomorphism

    author = {Morten Heine B. Sørensen and Pawel Urzyczyn},
    title = {Lectures on the Curry-Howard Isomorphism},
    year = {1998}

Functional Reactive Animation

   title        = {Functional Reactive Animation},
   url          = {},
   author       = "Conal Elliott and Paul Hudak",
   booktitle    = "International Conference on Functional Programming",
   year         = 1997

Growing a Languages

Growing a Language Guy L. Steele Jr. Sun Microsystems Laboratories 1 Network Drive Burlington, Massachusetts 01803 October 1998