Table of Contents

http://www.citeulike.org/user/jwalsh/ http://www.goodreads.com/review/list/5368953?shelf=currently-reading

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

2 Professional JavaScript for Web Developers

3 Functional Programming and the Lambda Calculus

4 The Lambda Calculus, Its Syntax and Semantics

5 λ-Calculus: Then & Now

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

http://turing100.acm.org/lambda_calculus_timeline.pdf

6 A Useful λ-Notation

http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.15.6554

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.

7 The formal system λδ

8 An Interpreter for Extended Lambda Calculus

AI Memo No. 349, December 1979

file:///Users/jwalsh/Dropbox/Books/AIM-349.pdf

http://repository.readscheme.org/ftp/papers/ai-lab-pubs/AIM-349.pdf

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,

  • CoffeeScript
  • JavaScript
  • Scheme
  • Lambda Calculus
  • Proof theory
  • Logic

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.

9 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:

10 The Road to Modern Logic - An Interpretation

11 The Completion of the Emergence of Modern Logic

… from Boole’s The Mathematical Analysis of Logic to Frege’s Begriffsschrift http://link.springer.com/chapter/10.1007/978-3-642-18026-2_10#page-2

12 The Org Mode 7 Reference Manual

12.1 Tables

  • Using C-c = for adding calculations

12.2 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'.

12.3 Dates and Times

  • Using scheduled dates more agressively

12.4 Capture

  • Using base capture templates
  • Added emacsclient

12.5 Agendas

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

12.6 Mobile

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

12.7 Easy Templates

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

13 A Simpler Proof Theory for Nominal Logic

equivariance, freshness and abstraction.

14 Equivariance and Invariance

http://mason.gmu.edu/~jgentle/csi9723/11s/l08b_11s.pdf

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).

15 Higher-Order Abstract Syntax: Setting the Record Straight

16 Nominal logic, a first order theory of names and binding

17 Nominal Logic Programming

http://www.inf.ed.ac.uk/teaching/courses/lp/

http://www.cl.cam.ac.uk/~amp12/talks/tacs01.pdf

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

18 First-Order Logic

@book{smullyan1968first,
  title={First-Order Logic},
  author={Smullyan, R.M.},
  isbn={9783642867187},
  series={Erg. d. Math. u. i. Grenzgeb},
  url={http://books.google.com/books?id=eq5GNAEACAAJ},
  year={1968},
  publisher={Springer Berlin Heidelberg}
}

19 Learn Prolog Now!

20 AdSentry: comprehensive and flexible confinement of JavaScript-based advertisements

21 An Introduction to Functional Programming through Lambda Calculus

21.1 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.

22 ToMaTo: a trustworthy code mashup development tool

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

24 Partitioning graphs to speedup Dijkstra's algorithm

25 Purely functional data structures

26 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: http://www.jstor.org/stable/3129899

27 Learn You a Haskell

28 Tree-Manipulating Systems and Church-Rosser Theorems

29 The functional power of parameter passage mechanism

30 Learning from the Web

31 On the security of public-key protocols

32 HTTP Cookies: Standards, privacy, and politics

33 Web caching on smartphones: ideal vs. reality

34 Selecting a hashing algorithm

35 JavaScript as an embedded DSL

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

37 The Joy of Clojure: Thinking the Clojure Way   clojure

On Kindle.

  • ch4: automatic promotion on overflow

38 Programming Clojure   clojure

39 EMACS the extensible, customizable self-documenting display editor

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

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

42 Mixin-based inheritance

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

44 Javascript bible, sixth edition   javascript

45 Status report: specifying JavaScript with ML

46 ECMA-262: ECMAScript Language Specification   javascript

47 10 Immutable Laws of Security

48 Graded Browser Support

49 The Promise System

50 Channels: A Generalization of Streams

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

52 Async JavaScript: Build More Responsive Apps with Less Code

http://pragprog.com/book/tbajs/async-javascript

You purchased this item on July 13, 2012.

53 The Uses of Knowledge in Society

54 A Universal Modular ACTOR Formalism for Artificial Intelligence

55 Design Patterns, Elements Of Reusable Object-Oriented Software

56 A Security Kernel Based on the Lambda-Calculus

57 The Architecture of Complexity

58 Measuring Relative Attack Surfaces

59 Toward a Critical Theory of Cyberspace

60 Hedgehog Architecture

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

http://www.comp.nus.edu.sg/~liangzk/papers/acns12.pdf

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.

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

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

@inproceedings{Jang:2010:ESP:1866307.1866339,
 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 = {http://doi.acm.org/10.1145/1866307.1866339},
 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")

64 TODO Privacy leakage in mobile online social networks

http://web.cs.wpi.edu/~cew/papers/wosn10.pdf

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.

65 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.

66 Keeping information safe from social networking apps

67 Privacy-aware identity management for client-side mashup applications

68 Web user de-identification in personalization

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

70 Formal specification of a JavaScript module system

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

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

72 The case for JavaScript transactions: position paper

73 TODO Automated Analysis of Security-Critical JavaScript APIs   javascript

74 When browsing leaves footprints: automatically detect privacy violations

@inproceedings{Hofinger:2012:BLF:2181196.2181205,
 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 = {http://doi.acm.org/10.1145/2181196.2181205},
 doi = {10.1145/2181196.2181205},
 acmid = {2181205},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {Firefox add-on, PRIVIDOR, privacy violations, web},
}

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

@inproceedings{Chen:2011:AIG:2046707.2046734,
 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 = {http://doi.acm.org/10.1145/2046707.2046734},
 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},
}

76 AdSentry: Comprehensive and Flexible Confinement of JavaScript-based Advertisements

77 DONE Fast, Scalable Detection of “Piggybacked” Mobile Applications

Malware Family Module Name # Piggybacked Apps
Geinimi om.geinimi 6
ADRD om.xxx.yyy 1
Pjapps om.android.main 8
DDream om.android.root 10
BgServ om.mms.bg 1

78 The open-closed principle

@incollection{Martin:2000:OP:331120.331143,
 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 = {http://dl.acm.org/citation.cfm?id=331120.331143},
 acmid = {331143},
 publisher = {Cambridge University Press},
 address = {New York, NY, USA},
}

Listed in http://en.wikipedia.org/wiki/Open/closed_principle

79 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.

@inproceedings{Xu:2005:ROP:1090950.1091578,
 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 = {http://dx.doi.org/10.1109/ICIS.2005.107},
 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},
}

80 JavaScript: The Good Parts   javascript

81 JavaScript: The Definitive Guide   javascript

82 Third-Party Javascript   javascript

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

82.1 TODO Subdomain proxies

This should be reviewed more deeply.

82.2 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).

83 Maintainable JavaScript   javascript

84 Programming JavaScript Applications

Picked up during the Fluent sale.

84.1 Chapter 5. Modules

This seems to have the best discussion of modules.

http://chimera.labs.oreilly.com/books/1234000000262/ch05.html

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.

http://esa-matti.suuronen.org/blog/2013/03/22/journey-from-requirejs-to-browserify/

85 Upgrading to RequireJS 2.1

86 Design Patterns

Program to an interface, not an implementation.

(quoted in )

87 JavaScript Enlightenment

  • Get a short and digestible summary of ECMA-262, Edition 3, backed by real code you can run instantly
  • Examine the creation of JavaScript objects
  • Learn complex values, primitive values, scope, and inheritance
  • Understand the importance of the head object
  • Work with string, number, and Boolean objects and values
  • Discover how to use the null value and the built-in math object
  • Get into the details—beyond Mozilla’s reference guide for JavaScript 1.5

88 Test-Driven JavaScript Development   javascript

89 JavaScript Patterns   javascript

90 Secrets of the Javascript Ninja   javascript

91 Eloquent JavaScript: A Modern Introduction to Programming   javascript

92 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.

@article{Chugh:2012:DTJ:2398857.2384659,
 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 = {http://doi.acm.org/10.1145/2398857.2384659},
 doi = {10.1145/2398857.2384659},
 acmid = {2384659},
 publisher = {ACM},
 address = {New York, NY, USA},
 keywords = {JavaScript, arrays, prototype inheritance, refinement types, strong updates},
}

93 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.

@inproceedings{Jensen:2009:TAJ:1615441.1615460,
 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 = {http://dx.doi.org/10.1007/978-3-642-03237-0_17},
 doi = {10.1007/978-3-642-03237-0_17},
 acmid = {1615460},
 publisher = {Springer-Verlag},
 address = {Berlin, Heidelberg},
}

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

@book{Souders:2009:EFW:1717800,
 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

  • different domain
    • no order
    • preserve order
  • same domain
    • no order
      • no busy
      • show busy
    • preserve order
      • no busy
      • show busy

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

95 The Dispossessed

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

@book{guin2009dispossessed,
  title={The Dispossessed},
  author={Guin, U.K.L.},
  isbn={9780061796883},
  url={http://books.google.com/books?id=k1Smynbdy\_IC},
  year={2009},
  publisher={HarperCollins}
}

96 Makers

97 Windup Girl

98 South of the Border, West of the Sun

99 Anathem

100 Accelerando

101 Evolution of Cooperation

102 Beyond the Hoax

103 Clojue Data Analysis Cookbook   clojure

104 CyberStorm

105 Quiet

106 Vision of Buddhism

107 Facets of Buddhism

108 Tao is Silent

109 Painted Birds

110 Nexus

  • Transhumanism
  • Cyborgs

111 Tractatus Logico-Philophicus

112 Rissa and Tregare

113 Young Rissa

114 Programming in Scala

115 GNU Emacs Extensions

116 Lake

117 This Perfect Day

118 Best Writing on Mathematics 2012

119 HTML5 for Publishers

120 ClojureScript: Up and Running   clojure

121 Clojure in Action

122 From the Teeth of Angels

123 American Psycho

124 Day of the Triffids

125 Slaughterhouse - Five

126 Ubik

127 Clown

128 Signal and the Noise

129 Effective JavaScript   javascript

130 Irony of American History

131 Fire Upon the Deep

132 Understanding Power

133 Prague Cemetery

134 Infinite Jest

135 Doing Capitalism in the Innovation Economy

136 The Great Thoughts

137 Well-Grouynded Rubyist

138 Rails 3 in Action   rails

139 Rails 4 in Action   rails

140 Age of Insight

141 Social Conquest of Earth

142 JavaScript Web Applications   javascript

143 Large Web Applications   javascript

144 Kafka on the Shore

145 Speaker for the Dead

146 Thinking Fast and Slow

147 Think Complexity

148 Antifragile

149 Foundation

150 Functional Programming in Scala

151 Linked Data

152 Do Androids Dream of Electric Sheep?

153 A Scanner Darkly

154 Thinking Statistically

155 Programming Problems

156 Ender's Shadow

157 Reasoned Schemer

@book{friedman2005reasoned,
  title={The reasoned schemer},
  author={Friedman, D.P. and Byrd, W.E. and Kiselyov, O.},
  isbn={9780262562140},
  lccn={2005051092},
  url={http://books.google.com/books?id=\_xciAQAAIAAJ},
  year={2005},
  publisher={MIT Press}
}

158 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.

http://tools.ietf.org/html/rfc6265#section-5.2

159 1Q84

160 Norwegian Wood

161 Woman in the Dunes

162 1984

163 Brothers Karamozov

164 Babel-17

http://en.wikipedia.org/wiki/Babel-17

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.

165 Snow Crash

166 JPod

http://en.wikipedia.org/wiki/JPod

  • read while in Germany

167 Neuromancer

http://en.wikipedia.org/wiki/Neuromancer

  • Sprawl trilogy
  • Gibson
  • 1984
  • Case (Henry Dorsett Case)

168 Count Zero

169 Mona Lisa Overdrive

  • 1988
  • Mona
  • Kumiko

170 Patern Recognition

http://en.wikipedia.org/wiki/Pattern_Recognition_(novel)

  • Cayce Pollard
  • Hubertus Bigend

Viral marketing with anonymous artistic clips.

171 Spook country

  • Hollis Henry
  • Tito
  • New York, Vancouver

172 Zero History

http://en.wikipedia.org/wiki/Zero_History

  • Hollis Henry
  • Milgrim
  • Gabriel Hounds
  • Garreth
  • London, Japan

173 The VAL Language: Description and Analysis

@article{McGraw:1982:VLD:357153.357157,
 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 = {http://doi.acm.org/10.1145/357153.357157},
 doi = {10.1145/357153.357157},
 acmid = {357157},
 publisher = {ACM},
 address = {New York, NY, USA},
}

174 Coproducts of Monads on Set

175 Extending Monads with Pattern Matching

176 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.

177 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.

178 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.

179 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.

180 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.

181 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.

182 Building Interpreters by Composing Monads

183 Making Monads First-class with Template Haskell

184 Monad Transformers Step by Step

185 Monad Transformers Step by Step

186 The Marriage of Effects and Monads

187 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.

188 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 (http://stevesouders.com/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 = ‘http://anydomain.com/foo.js’; document.getElementsByTagName(‘head’). appendChild(se); </script>

189 Using types as search keys in function libraries

@inproceedings{Rittri:1989:UTS:99370.99384,
 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 = {http://doi.acm.org/10.1145/99370.99384},
 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

190 Retrieving re-usable software components by polymorphic type

@inproceedings{Runciman:1989:RRS:99370.99383,
 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 = {http://doi.acm.org/10.1145/99370.99383},
 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.

191 On Lisp

On Lisp Prolog interpretter http://dunsmor.com/lisp/onlisp/onlisp_28.html

192 SICP

193 SICM

194 Paradigms of Artificial Intelligence Programming

195 Push-pull functional reactive programming

@InProceedings {Elliott2009-push-pull-frp,
  author    = {Conal Elliott},
  title     = {Push-pull functional reactive programming},
  booktitle = {Haskell Symposium},
  url       = {http://conal.net/papers/push-pull-frp},
  year      = 2009
}

http://conal.net/papers/push-pull-frp/

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.

196 Denotational design with type class morphisms

197 Functional Reactive Animation

http://conal.net/papers/icfp97/

@InProceedings{ElliottHudak97:Fran,
  title        = {Functional Reactive Animation},
  url          = {http://conal.net/papers/icfp97/},
  author       = "Conal Elliott and Paul Hudak",
  booktitle    = "International Conference on Functional Programming",
  year         = 1997
}

198 Two Techniques for Compiling Lazy Pattern Matching

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

199 Lectures on the Curry-Howard Isomorphism

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

200 Functional Reactive Animation

@InProceedings{ElliottHudak97:Fran,
   title        = {Functional Reactive Animation},
   url          = {http://conal.net/papers/icfp97/},
   author       = "Conal Elliott and Paul Hudak",
   booktitle    = "International Conference on Functional Programming",
   year         = 1997
 }

201 Growing a Languages

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

Author: Jason Walsh

Created: 2016-11-01 Tue 12:12

Validate