A glimpse of my reading habits

This is my reading list, it contains stuff that I've stumbled upon while studying or casually browsed the web.

When stuff is read they end up in the archive.

## 1 Articles

These articles are articles that I stumble upon while studying or casually exploring different libraries and what not.

More often than not it will be Haskell/functional programming-related, but that is not to say that I limit myself to those subjects.

### 1.1READING Dependent Types at Work   type theory functional programming article

Author(s): Ana Bove, Peter Dybjer

Abstract: In these lecture notes we give an introduction to functional programming with dependent types. We use the dependently typed programming language Agda which is an extension of Martin-Löf type theory. First we show how to do simply typed functional programming in the style of Haskell and ML. Some differences between Agda’s type system and the Hindley-Milner type system of Haskell and ML are also discussed. Then we show how to use dependent types for programming and we explain the basic ideas behind type-checking dependent types. We go on to explain the Curry-Howard identification of propositions and types. This is what makes Agda a programming logic and not only a pro- gramming language. According to Curry-Howard, we identify programs and proofs, something which is possible only by requiring that all program terminate. However, at the end of these notes we present a method for encoding partial and general recursive functions as total functions using dependent types.

• [57%] Chapters
• [X] 1. What are Dependent Types
• [X] 2. Simply Typed Functional Programming in Agda
• [X] 2.1 Truth Values
• [X] 2.2 Natural Numbers
• [X] 2.3 Lambda Notation and Polymorphism
• [X] 2.4 Implicit Arguments
• [X] 2.5 Gödel System T
• [X] 2.6 Parametrised Types
• [X] 2.7 Termination Checking
• [X] 3. Dependent Types
• [X] 3.1 Vectors of a Given Length
• [X] 3.2 Finite Sets
• [X] 3.3 More Inductive Families
• [-] 4. Propositions as Types
• [X] 4.1 Propositional Logic
• [ ] 4.2 Predicate Logic
• [X] 4.3 Equality
• [ ] 4.4 Induction Principles
• [X] 5. Type-checking Dependent Types
• [X] 5.1 Pattern Matching with Dependent Types
• [X] 5.2 Normalisation during Type-checking
• [ ] 6. Agda as a Programming Logic
• [ ] 6.1 The Data Type of Binary Trees and the Sorted Predicate
• [ ] 6.2 An Inductive-recursive Definition of Binary Search Trees
• [ ] 6.3 Bounded Binary Search Trees
• [ ] 7. General Recursion and Partial Functions

#### 1.1.1 Inductive families of balanced trees

Just as we can use dependent types for defining lists of a certain length, we can use them for defining binary trees of a certain height:

data DBTree (A : Set) : Nat -> Set where
dlf : A -> DBTree A zero
dnd : {n : Nat} -> DBTree A n -> DBTree A n -> DBTree A (succ n)


With this definition, any given (t : DBTree A n) is a perfectly balanced tree with 2 n elements and information in the leaves.

It's very interesting that you can define inductive data types based on height and in that way ensure that the trees always will be balanced.

[2017-09-09 lör 14:05]

### 1.2WANT-TO-READ A Meta-EDSL for Distributed Web Applications

Author: Anton Ekblad Conference: ICFP 2017

Abstract: We present a domain-specific language for constructing and configuring web applications distributed across any number of networked, heterogeneous systems. Our language is embedded in Haskell, provides a common framework for integrating components written in third-party EDSLs, and enables type-safe, access-controlled communication between nodes, as well as effortless sharing and movement of functionality between application components. We give an implementation of our language and demonstrate its applicability by using it to implement several important components of distributed web applications, including RDBMS integration, load balancing, and fine-grained sandboxing of untrusted third party code. The rising popularity of cloud computing and heterogeneous computer architectures is putting a strain on conventional programming models, which commonly assume that one application executes on one machine, or at best on one out of several identical machines. With our language, we take the first step towards a programming model better suited for a computationally multicultural future.

### 1.3WANT-TO-READ A tutorial on the universality and expressiveness of fold   article functional programming programming

Author: Graham Hutton Journal: Journal of Functional Programming 9 (4): 355–372, July 1999

### 1.4WANT-TO-READ Eventless Reactivity from Scratch   article functional programming programming

Author: Gergely Patai University: Budapest University of Technology and Economics

### 1.6READING Clowns to the Left of me, Jokers to the Right: Dissecting Data Structures

Author: Conor McBride Journal: The Journal of Functional Programming (Functional Pearl)

The article that inspired the Clown and Joker Bifunctors…

### 1.7WANT-TO-READ Purely Functional Data Structures

Author: Chris Okasaki

A PhD thesis at Carnegie Mellon University, this thesis is a less complete precursor to the book Purely Functional Data Structures by Okasaki.

Author: Simon Marlow, Ryan Newton and Simon Peyton Jones

Abstract: "We present a new programming model for deterministic parallel computation in a pure functional language. The model is monadic and has explicit granularity, but allows dynamic construction of dataflow networks that are scheduled at runtime, while remaining deterministic and pure. The implementation is based on monadic concurrency, which has until now only been used to simulate concurrency in functional languages, rather than to provide parallelism. We present the API with its semantics, and argue that parallel execution is deterministic. Furthermore, we present a complete work-stealing scheduler implemented as a Haskell library, and we show that it performs at least as well as the existing parallel programming models in Haskell."

### 1.9WANT-TO-READ Algorithm + Strategy = Parallelism

Author: P.W. Trinder, K. Hammond, H.-W. Loidl and S.L. Peyton Jones

Abstract: "The process of writing large parallel programs is complicated by the need to specify both the parallel behaviour of the program and the algorithm that is to be used to compute its result. This paper introduces evaluation strategies, lazy higher-order functions that control the parallel evaluation of non-strict functional languages. Using evaluation strategies, it is possible to achieve a clean separation between algorithmic and behavioural code. The result is enhanced clarity and shorter parallel programs. Evaluation strategies are a very general concept: this paper shows how they can be used to model a wide range of commonly used programming paradigms, including divide- and-conquer, pipeline parallelism, producer/consumer parallelism, and data-oriented parallelism. Because they are based on unrestricted higher-order functions, they can also capture irregular parallel structures. Evaluation strategies are not just of theoretical interest: they have evolved out of our experience in parallelising several large-scale parallel applications, where they have proved invaluable in helping to manage the complexities of parallel behaviour. These applications are described in detail here. The largest application we have studied to date, Lolita, is a 60,000 line natural language parser. Initial results show that for these programs we can achieve acceptable parallel performance, while incurring minimal overhead for using evaluation strategies."

Author: Simon Marlow, Patrick Maier, Hans-Wolfgang Loidl, Mustafa K. Aswad and Phil Trinder

Abstract: "We present a complete redesign of evaluation strategies, a key abstraction for specifying pure, deterministic parallelism in Haskell. Our new formulation preserves the compositionality and modularity benefits of the original, while providing significant new benefits. First, we introduce an evaluation-order monad to provide clearer, more generic, and more efficient specification of parallel evaluation. Secondly, the new formulation resolves a subtle space management issue with the original strategies, allowing parallelism (sparks) to be preserved while reclaiming heap associated with superfluous parallelism. Related to this, the new formulation provides far better support for speculative parallelism as the garbage collector now prunes unneeded speculation. Finally, the new formulation provides improved compositionality: we can directly express parallelism embedded within lazy data structures, producing more compositional strategies, and our basic strategies are parametric in the coordination combinator, facilitating a richer set of parallelism combinators.

We give measurements over a range of benchmarks demonstrating that the runtime overheads of the new formulation relative to the original are low, and the new strategies even yield slightly better speedups on average than the original strategies"

### 1.11READING Design Exploration through Code-generating DSLs

Authors: Bo Joel Svensson, Mary Sheeran, Ryan Newton.

Abstract: DSLs (domain-specific languages) make programs shorter and easier to write. They can be stand-alone—for example, LaTeX, Makefiles, and SQL—or they can be embedded in a host language. You might think that DSLs embedded in high-level languages would be abstract or mathematically oriented, far from the nitty-gritty of low-level programming. This is not the case. This article demonstrates how high-level EDSLs (embedded DSLs) really can ease low-level programming. There is no contradiction.

A gentle introduction to EDSLs can be found in the previous article in this series: "Domain-specific Languages and Code Synthesis Using Haskell," in which Andy Gill considers the pros and cons of implementing a deeply embedded DSL, compared with a stand-alone compiler. Here, the story continues, posing a slightly different question: If you need to produce high-performance, low-level code in a language such as C or CUDA, is it worthwhile to use (or create) a code-generating EDSL, or should you just buckle down and write the low-level code by hand? Our answer is that the EDSL may well be a reasonable option.

### 1.12WANT-TO-READ I-Structures: Data Structures for Parallel Computing

Author: Arvind (MIT), Rishiyur S. Nikhil (MIT) and Keshav K. Pingali (Cornell University)

Abstract: "It is difficult to achieve elegance, effciency and parallelism simultaneously in functional programs that manipulate large data structures. We demonstrate this through careful analysis of program examples using three common functional data-structuring approaches – lists using Cons and arrays using Update (both fine-grained operators), and arrays using make_array (a "bulk" operator). We then present I-structures as an alternative, and show elegant, efficient and parallel solutions for the program examples in Id, a language with I-structures. The parallelism in Id is made precise by means of an operational semantics for Id as a parallel reduction system. I-structures make the language nonfunctional, but do not lose determinacy. Finally, we show that even in the context of purely functional languages, I-structures are invaluable for implementing functional data abstractions.

### 1.13WANT-TO-READ A critique of Abelson and Sussman

This paper discusses why a programming language such as KRC or Miranda would be a better candidate for teaching programming instead of Scheme.

Author: Conal Elliot

Abstract: It is well-known that the simply typed lambda-calculus is modeled by any cartesian closed category (CCC). This correspondence suggests giving typed functional programs a variety of interpretations, each corresponding to a different category. A convenient way to realize this idea is as a collection of meaning-preserving transformations added to an existing compiler, such as GHC for Haskell. This paper describes such an implementation and demonstrates its use for a variety of interpretations including hardware circuits, automatic differentiation, incremental computation, and interval analysis. Each such interpretation is a category easily defined in Haskell (outside of the compiler). The general technique appears to provide a compelling alternative to deeply embedded domain-specific languages.

Author: Mark P. Jones

Abstract: The Hindley/Milner type system has been widely adopted as a basis for statically typed functional languages. One of the main reasons for this is that it provides an elegant compromise between flexibility, allowing a single value to be used in different ways, and practicality, freeing the programmer from the need to supply explicit type information. Focusing on practical applications rather than implementation or theoretical details, these notes examine a range of extensions that provide more flexible type systems while retaining many of the properties that have made the original Hindley/Milner system so popular. The topics discussed, some old, but most quite recent, include higher-order polymorphism and type and constructor class overloading. Particular emphasis is placed on the use of these features to promote modularity and reusability.

### 1.16WANT-TO-READ Operations on Records   type therory

Author(s): Luca Cardelli, John Mitchell

Abstract: We define a simple collection of operations for creating and manipulating record structures, where records are intended as finite associations of values to labels. A second-order type system over these operations supports both subtyping and polymorphism. We provide typechecking algorithms and limited semantic models.

Our approach unifies and extends previous notions of records, bounded quantification, record extension, and parametrization by row-variables. The general aim is to provide foundations for concepts found in object-oriented languages, within a framework based on typed lambda-calculus.

### 1.17WANT-TO-READ Algebraic Effects   functional programming

Author(s): Daan Leijen

Abstract: Algebraic effect handlers, are recently gaining in popularity as a purely functional approach to modeling effects. In this article, we give an end-to-end overview of practical algebraic effects in the context of a compiled implementation in the Koka language. In particular, we show how algebraic effects generalize over common constructs like exception handling, state, iterators and async-await. We give an effective type inference algorithm based on extensible effect rows using scoped labels, and a direct operational semantics. Finally, we show an efficient compilation scheme to common run-time platforms (such as JavaScript, the JVM, or .NET) using a type directed selective CPS translation.

### 1.18WANT-TO-READ The Mechanical Evaluation of Expressions   cs functional programming

Author(s): Peter Landin

Abstract: This paper is a contribution to the “theory” of the activity of using computers. It shows how some forms of expression used in current programming languages can be modelled in Church's λ-notation, and then describes a way of “interpreting” such expressions. This suggests a method, of analyzing the things computer users write, that applies to many different problem orientations and to different phases of the activity of using a computer. Also a technique is introduced by which the various composite information structures involved can be formally characterized in their essentials, without commitment to specific written or other representations.

### 1.19WANT-TO-READ Language-Based Information-Flow Security   security programming languages functional

Author(s): Andrew Myers and Andrei Sabelfield

Abstract: Current standard security practices do not provide substantial assurance that the end-to-end behavior of a computing system satisfies important security policies such as confidentiality. An end-to-end confidentiality policy might assert that secret input data cannot be inferred by an attacker through the attacker’s observations of system output; this policy regulates information flow. Conventional security mechanisms such as access control and encryption do not directly address the enforcement of information-flow policies. Recently, a promising new approach has been developed: the use of programming-language techniques for specifying and enforcing information-flow policies. In this article we survey the past three decades of research on information-flow security, particularly focusing on work that uses static program analysis to enforce information-flow policies. We give a structured view of recent work in the area and identify some important open challenges.

Author(s): Thorsten Altenkirch, Nils Anders Danielsson, Nicolai Kraus

Abstract: Capretta’s delay monad can be used to model partial computations, but it has the “wrong” notion of built-in equality, strong bisimilarity. An alternative is to quotient the delay monad by the “right” notion of equality, weak bisimilarity. However, recent work by Chapman et al. suggests that it is impossible to define a monad structure on the resulting construction in common forms of type theory without assuming (instances of) the axiom of countable choice. Using an idea from homotopy type theorya higher inductive-inductive type we construct a partiality monad without relying on countable choice. We prove that, in the presence of countable choice, our partiality monad is equivalent to the delay monad quotiented by weak bisimilarity. Furthermore we outline several applications.

### 1.21READING Linear Haskell: Practical linearity in a higher-order polymorphic language   functional programming article haskell linear logic

Author(s): Bernardy et al.

Abstract: Linear type systems have a long and storied history, but not a clear path forward to integrate with existing languages such as OCaml or Haskell. In this paper, we study a linear type system designed with two crucial properties in mind: backwards-compatibility and code reuse across linear and non-linear users of a library. Only then can the benefits of linear types permeate conventional functional programming. Rather than bifurcate types into linear and non-linear counterparts, we instead attach linearity to function arrows. Linear functions can receive inputs from linearly-bound values, but can also operate over unrestricted, regular values. To demonstrate the efficacy of our linear type system — both how easy it can be integrated in an existing language implementation and how streamlined it makes it to write programs with linear types — we implemented our type system in ghc, the leading Haskell compiler, and demonstrate two kinds of applications of linear types: mutable data with pure interfaces; and enforcing protocols in I/O-performing functions.

### 1.22WANT-TO-READ Into the Infinite - Theory Exploration for Coinduction   cs fp logic

Author(s): Sólrún Halla Einarsdóttir, Moa Johansson, Johannes Åman Pohjola

Abstract: Theory exploration is a technique for automating the discovery of lemmas in formalizations of mathematical theories, using testing and automated proof techniques. Automated theory exploration has previously been successfully applied to discover lemmas for inductive theories, about recursive datatypes and functions. We present an extension of theory exploration to coinductive theories, allowing us to explore the dual notions of corecursive datatypes and functions. This required development of new methods for testing infinite values, and for proof automation. Our work has been implemented in the Hipster system, a theory exploration tool for the proof assistant Isabelle/HOL.

### 1.23WANT-TO-READ Time, Clocks, and the Ordering of Events in a Distributed System   distributed system

Author(s): Leslie Lamport

Abstract: The concept of one event happening before another in a distributed system is examined, and is shown to define a partial ordering of the events. A distributed algorithm is given for synchronizing a system of logical clocks which can be used to totally order the events. The use of the total ordering is illustrated with a method for solving synchronization problems. The algorithm is then specialized for synchronizing physical clocks, and a bound is derived on how far out of synchrony the clocks can become.

### 1.24WANT-TO-READ Dynamo: Amazon's Highly Available Key-value Store   distributed system

Author(s): Giuseppe DeCandia, Deniz Hastorun, Madan Jampani, Gunavardhan Kakulapati, Avinash Lakshman, Alex Pilchin, Swaminathan Sivasubramanian, Peter Vosshall and Werner Vogels

Abstract: Reliability at massive scale is one of the biggest challenges we face at Amazon.com, one of the largest e-commerce operations in the world; even the slightest outage has significant financial consequences and impacts customer trust. The Amazon.com platform, which provides services for many web sites worldwide, is implemented on top of an infrastructure of tens of thousands of servers and network components located in many datacenters around the world. At this scale, small and large components fail continuously and the way persistent state is managed in the face of these failures drives the reliability and scalability of the software systems.

This paper presents the design and implementation of Dynamo, a highly available key-value storage system that some of Amazon’s core services use to provide an “always-on” experience. To achieve this level of availability, Dynamo sacrifices consistency under certain failure scenarios. It makes extensive use of object versioning and application-assisted conflict resolution in a manner that provides a novel interface for developers to use.

### 1.25WANT-TO-READ Typing the Wild in Erlang   functional programming cs fp languages

Author(s): Nachiappan Valliappan

Abstract: Developing a static type system suitable for Erlang has been of ongoing interest for almost two decades now. The challenge with retrofitting a static type system onto a dynamically typed language, such as Erlang, is the loss of flexibility in programming offered by the language. In light of this, many attempts to type Erlang trade sound type checking for the ability to retain flexibility. Hence, simple type errors which would be caught by the type checker of a statically typed language are easily missed in these developments. This has us wishing for a way to avoid such errors in Erlang programs.

In this paper, we develop a static type system for Erlang which strives to remain sound without being too restrictive. Our type system is based on Hindley-Milner type inference, however it – unlike contemporary implementations of Hindley-Milner – is flexible enough to allow overloading of data constructors, branches of different types etc. Further, to allow Erlang’s dynamic type behaviour, we employ a program specialization technique called partial evaluation. Partial evaluation simplifies programs prior to type checking, and hence enables the type system to type such behaviour under certain restricted circumstances.

### 1.26WANT-TO-READ Bidirectional Testing of Communicating Systems   functional programming fp languages

Author: Maximilian Algehed

Abstract: This report presents a new tool called SessionCheck. This tool helps programmers write distributed applications that work correctly. SessionCheck is designed to help rid programmers of the tedium of maintaining more than one specification and test suite for multiple application components. SessionCheck does this by borrowing ideas from session types [14] and domain specific languages in order to provide a simple yet expressive and compositional specification language for communication protocols. Specifications written in the SessionCheck specification language can be used to test both client and server implementations of the same protocol in a completely language-agnostic manner.

Author(s): Andy Gill & Graham Hutton

Abstract: The worker/wrapper transformation is a technique for changing the type of a computation, usually with the aim of improving its performance. It has been used by compiler writers for many years, but the technique is little known in the wider functional programming community, and has never been described precisely. In this article we explain, formalise and explore the generality of the worker/wrapper transformation. We also provide a systematic recipe for its use as an equational reasoning technique for improving the performance of programs, and illustrate the power of this recipe using a range of examples.

### 1.28WANT-TO-READ Implementing lazy functional languages on stock hardware: the Spineless Tagless G-machine   programming functional haskell

Abstract: The Spineless Tagless G-machine is an abstract machine designed to support non-strict higher-order functional languages. This presentation of the machine falls into three parts. Firstly, we give a general discussion of the design issues involved in implementing non-strict functional languages. Next, we present the STG language, an austere but recognisably-functional language, which as well as a denotational meaning has a well-de ned operational semantics. The STG language is the abstract machine code for the Spineless Tagless G-machine. Lastly, we discuss the mapping of the STG language onto stock hardware. The success of an abstract machine model depends largely on how eficient this mapping can be made, though this topic is often relegated to a short section. Instead, we give a detailed discussion of the design issues and the choices we have made. Our principal target is the C language, treating the C compiler as a portable assembler.

Author(s): - CSONGOR KISS, Imperial College London, United Kingdom

• SUSAN EISENBACH, Imperial College London, United Kingdom
• TONY FIELD, Imperial College London, United Kingdom
• SIMON PEYTON JONES, Microsoft Research, United Kingdom

Abstract: Type family applications in Haskell must be fully saturated. This means that all type-level functions have to be first-order, leading to code that is both messy and longwinded. In this paper we detail an extension to GHC that removes this restriction. We augment Haskell’s existing type arrow, → , with an unmatchable arrow, ↠, that supports partial application of type families without compromising soundness. A soundness proof is provided. We show how the techniques described can lead to substantial code-size reduction (circa 80%) in the type-level logic of commonly-used type-level libraries whilst simultaneously improving code quality and readability.

### 1.30WANT-TO-READ A Few Billion Lines Of Code Later: Using Static Analysis to Find Bugs in the Real World

Author(s): - Al Bessey,

• Ken Block,
• Ben Chelf,
• Andy Chou,
• Bryan Fulton,
• Seth Hallem,
• Charles Henri-Gros,
• Asya Kamsky,
• Scott McPeak,
• Dawson Engler

First paragraph: In 2002, Coverity commercialized3 a research static bug-finding tool.6,9 Not surprisingly, as academics, our view of commercial realities was not perfectly accurate. However, the problems we encountered were not the obvious ones. Discussions with tool researchers and system builders suggest we were not alone in our naïveté. Here, we document some of the more important examples of what we learned developing and commercializing an industrial-strength bug-finding tool.

Author(s): Simon Peyton Jones, Andrew Gordon and Sigbjorn Finne

Abstract: Some applications are most easily expressed in a programming language that supports concurrency, notably interactive and distributed systems. We propose extensions to the purely-functional language Haskell that allow it to express explicitly concurrent applications; we call the resulting lan- guage Concurrent Haskell. The resulting system appears to be both expressive and efficient, and we give a number of examples of useful abstractions that can be built from our primitives. We have developed a freely-available implementation of Concurrent Haskell, and are now using it as a substrate for a graphical user interface toolkit.

## 2 Books

These books are either books that I am currently reading or books that are recommended to me or just books I've stumbled upon.

Books I've finished reading are found in the archive.

### 2.1WANT-TO-READ Working Effectively with Legacy Code

In this book, Michael Feathers offers start-to-finish strategies for working more effectively with large, untested legacy code bases. This book draws on material Michael created for his own renowned Object Mentor seminars: techniques Michael has used in mentoring to help hundreds of developers, technical managers, and testers bring their legacy systems under control. This book also includes a catalog of twenty-four dependency-breaking techniques that help you work with program elements in isolation and make safer changes.

Author: Michael Feathers

Even bad code can function. But if code isn’t clean, it can bring a development organization to its knees. Every year, countless hours and significant resources are lost because of poorly written code. But it doesn’t have to be that way.

Author: Robert C. Martin

Progress: p. 7

The source code for the book is available on Github: TheBeamBook

A book written by Erik Stenman, about how the Erlang VM (Beam) works. It probably covers some of the design choices made when implementing the language and runtime.

The book is available to read online: PCPH book

A book written by Simon Marlow, a prior Microsoft researcher that worked on the GHC Haskell Compiler and now works at Facebook with labelling malicious behaviour using Haskell. The book covers how to use Haskell to write concurrent and parallel programs.

#### 2.4.1 Preface

As one of the developers of the Glasgow Haskell Compiler (GHC) for almost 15 years, I have seen Haskell grow from a niche research language into a rich and thriving ecosystem. I spent a lot of that time working on GHC’s support for parallelism and concurrency. One of the first things I did to GHC in 1997 was to rewrite its runtime system, and a key decision we made at that time was to build concurrency right into the core of the system rather than making it an optional extra or an add-on library. I like to think this decision was founded upon shrewd foresight, but in reality it had as much to do with the fact that we found a way to reduce the overhead of concurrency to near zero (previously it had been on the order of 2%; we’ve always been performance-obsessed). Nevertheless, having concurrency be non-optional meant that it was always a first-class part of the implementation, and I’m sure that this decision was instrumental in bringing about GHC’s solid and lightning-fast concurrency support.

Haskell has a long tradition of being associated with parallelism. To name just a few of the projects, there was the pH variant of Haskell derived from the Id language, which was designed for parallelism, the GUM system for running parallel Haskell programs on multiple machines in a cluster, and the GRiP system: a complete computer architecture designed for running parallel functional programs. All of these happened well before the current multicore revolution, and the problem was that this was the time when Moore’s law was still giving us ever-faster computers. Parallelism was difficult to achieve, and didn’t seem worth the effort when ordinary computers were getting exponentially faster.

Around 2004, we decided to build a parallel implementation of the GHC runtime system for running on shared memory multiprocessors, something that had not been done before. This was just before the multicore revolution. Multiprocessor machines were fairly common, but multicores were still around the corner. Again, I’d like to think the decision to tackle parallelism at this point was enlightened foresight, but it had more to do with the fact that building a shared-memory parallel implementation was an interesting research problem and sounded like fun. Haskell’s purity was essential—it meant that we could avoid some of the overheads of locking in the runtime system and garbage collector, which in turn meant that we could reduce the overhead of using parallelism to a low-single-digit percentage. Nevertheless, it took more research, a rewrite of the scheduler, and a new parallel garbage collector before the implementation was really usable and able to speed up a wide range of programs. The paper I presented at the International Conference on Functional Programming (ICFP) in 2009 marked the turning point from an interesting prototype into a usable tool.

All of this research and implementation was great fun, but good-quality resources for teaching programmers how to use parallelism and concurrency in Haskell were conspicuously absent. Over the last couple of years, I was fortunate to have had the opportunity to teach two summer school courses on parallel and concurrent programming in Haskell: one at the Central European Functional Programming (CEFP) 2011 summer school in Budapest, and the other the CEA/EDF/INRIA 2012 Summer School at Cadarache in the south of France. In preparing the materials for these courses, I had an excuse to write some in-depth tutorial matter for the first time, and to start collecting good illustrative examples. After the 2012 summer school I had about 100 pages of tutorial, and thanks to prodding from one or two people (see the Acknowledgments), I decided to turn it into a book. At the time, I thought I was about 50% done, but in fact it was probably closer to 25%. There’s a lot to say! I hope you enjoy the results.

This easy-to-use, fast-moving tutorial introduces you to functional programming with Haskell. You'll learn how to use Haskell in a variety of practical ways, from short scripts to large and demanding applications. Real World Haskell takes you through the basics of functional programming at a brisk pace, and then helps you increase your understanding of Haskell in real-world issues like I/O, performance, dealing with data, concurrency, and more as you move through each chapter.

### 2.6WANT-TO-READ The little Schemer   scheme lisp programming book

The notion that "thinking about computing is one of the most exciting things the human mind can do" sets both The Little Schemer (formerly known as The Little LISPer) and its new companion volume, The Seasoned Schemer, apart from other books on LISP. The authors' enthusiasm for their subject is compelling as they present abstract concepts in a humorous and easy-to-grasp fashion. Together, these books will open new doors of thought to anyone who wants to find out what computing is really about. The Little Schemer introduces computing as an extension of arithmetic and algebra; things that everyone studies in grade school and high school. It introduces programs as recursive functions and briefly discusses the limits of what computers can do. The authors use the programming language Scheme, and interesting foods to illustrate these abstract ideas. The Seasoned Schemer informs the reader about additional dimensions of computing: functions as values, change of state, and exceptional cases. The Little LISPer has been a popular introduction to LISP for many years. It had appeared in French and Japanese. The Little Schemer and The Seasoned Schemer are worthy successors and will prove equally popular as textbooks for Scheme courses as well as companion texts for any complete introductory course in Computer Science – MIT Press

### 2.7WANT-TO-READ The little Typer   dependent types book programming

Summary: An introduction to dependent types, demonstrating the most beautiful aspects, one step at a time.

A program's type describes its behavior. Dependent types are a first-class part of a language, and are much more powerful than other kinds of types; using just one language for types and programs allows program descriptions to be as powerful as the programs they describe. The Little Typer explains dependent types, beginning with a very small language that looks very much like Scheme and extending it to cover both programming with dependent types and using dependent types for mathematical reasoning. Readers should be familiar with the basics of a Lisp-like programming language, as presented in the first four chapters of The Little Schemer.

The first five chapters of The Little Typer provide the needed tools to understand dependent types; the remaining chapters use these tools to build a bridge between mathematics and programming. Readers will learn that tools they know from programming—pairs, lists, functions, and recursion—can also capture patterns of reasoning. The Little Typer does not attempt to teach either practical programming skills or a fully rigorous approach to types. Instead, it demonstrates the most beautiful aspects as simply as possible, one step at a time. – MIT Press

### 2.8READING Gödel, Escher, Bach - An Eternal Golden Braid   consciousness philosophy book

The book is an attempt by the author to discuss and present his thoughts of what it means to be "self-aware" or an "I" (have a feeling of self).

#### 2.8.1 Preface of the Twentieth-anniversary Edition

On the twentythree pages that make up the preface of the twentieth-anniversary edition Douglas R. Hofstadter (the author) discusses what he thinks the book is all about.

He also introduces the reader to some concepts (such that Gödelian loops and what it means to have a meaning) that he probably talks about in more detail in the book. As such the preface is a good preview of book and got me interesting and excited to read the rest of the book.

### 2.9READING Implementing Programming Languages   @study @coding programming functional book

A book that teaches programming languages constructions by defining a grammar and implementing a compiler for that grammar.

It is the course book for the course Programming Language Technology @ Chalmers.

#### 2.9.1[87%] Chapters

3. READ 3. Lexing and Parsing
7. READ 7. Functional Programming Languages
8. READING 8. The Language Design Space

### 2.10WANT-TO-READ Write Yourself a Scheme in 48 Hours   haskell scheme programming functional programming book

Interesting book that teaches Haskell by implementing a Scheme programming language using Haskell.

#### 2.10.1 Overview

Most Haskell tutorials on the web use a style of teaching akin to language reference manuals. They show you the syntax of the language, a few language constructs, then tell you to create a few simple functions at the interactive prompt. The "hard stuff" of how to write a functioning, useful program is left to the end, or omitted entirely.

This tutorial takes a different approach. You'll start off using and parsing the command-line, then progress to writing a fully-functional Scheme interpreter that implements a decent subset of R5RS Scheme. Along the way, you'll learn Haskell's I/O, mutable state, dynamic typing, error handling, and parsing features. By the time you finish, you should become fairly fluent in Haskell and Scheme.

This tutorial targets two main audiences:

• People who already know Lisp or Scheme, and want to learn Haskell
• People who don't know any programming language, but have a strong quantitative background, and are familiar with computers

The second group will likely find this challenging, as this tutorial glosses over several concepts in Scheme and general programming in order to stay focused on Haskell. A good textbook such as Structure and Interpretation of Computer Programs or The Little Schemer should be very helpful.

Users of a procedural or object-oriented language like C, Java, or Python should beware: You'll have to forget most of what you already know about programming. Haskell is completely different from those languages, and requires a different way of thinking about programming. It's best to go into this tutorial with a blank slate; try not to compare Haskell to imperative languages, because many concepts (including classes, functions, and return) have significantly different meanings in Haskell.

Since each lesson builds upon code written in previous ones, it's generally best to go through them in order.

A prior, non-wiki-edited version of the source code files used in this tutorial is available on the original site

It's the year 2044, and the real world has become an ugly place. Like most of humanity, Wade Watts escapes this depressing reality by spending his waking hours jacked into the OASIS, a sprawling virtual utopia where you can be anything you want to be, where you can live and play and fall in love on any of ten thousand planets.

A book written by Elise Huard about how to write games in Haskell.

I bought this book on Leanpub, link to the book.

Preface

Game Programming in Haskell, predictably gives an introduction on:

• how to write a game

It is a practical book with code examples and pointers to open source code repositories. The aim is to get the readers to develop their own game as painlessly as possible, so that they can skip the technical hurdles and concentrate on the hard part, which is making a fun, compelling, entertaining game.

Note: this book is in progress

### 2.13READING Types and Programming Languages   @study @coding types logic programming functional

The book is available to read online, through the Chalmers Library proxy: Types and Programming Languages

The study of type systems, and of programming languages from a typetheoretic perspective, has become an energetic field with major applications in software engineering, language design, high-performance compiler implementation, and security. This text offers a comprehensive introduction to the fundamental definitions, results, and techniques in the area.

This book is considered a course book for DAT350 on Chalmers.

#### 2.13.1[9%] Chapters

4. WANT-TO-READ An ML Implementation of Arithmetic Expressions
6. WANT-TO-READ Nameless Representation of Terms
7. WANT-TO-READ An ML Implementation of the Lambda-Calculus
10. WANT-TO-READ An ML Implementation of Simple Types

This chapter was about Subtyping. Subtyping enables the programmer to give a value of a different type S where the language/compiler expects a type T, given that S is a subtype of T. What "a subtype of T" means is expressed in the chapter in the context of simply typed lamba calculus with records and variants.

Some notes from the chapter:

• Coercion semantics are a reasonable compromise between making it easy for the programmer to write functions the way they expect and to keep the type safety.
• Intersection and Union types seems cool. The concept is taken from set/order semantics: a value belonging to the $$T_1 \land T_2$$ type is a value that is both in the set of $$T_1$$ values and $$T_2$$ values. Conversely a value in the $$T_1 \lor T_2$$ type is a value that is in either (or both) $$T_1$$ or $$T_2$$. I've added a todo to read more about intersection and union types
17. WANT-TO-READ An ML Implementation of Subtyping
18. READ Case Study: Imperative Objects

This chapter looks at what objects in the object oriented programming paradigm usually consist of and explains the concepts behind it in the context of simply typed lambda calculus.

The basic objects and classes used as examples are a basic counter, that is derived to counters that log the ticks and counters that can reset themselves.

Some notes from the chapter:

• Open recursion through the fix-point combinator was interesting.
• There was a discussion about evaluation order in combination to the open recursion and that one can postpone the evaluation of an expression by "thunking" (wrap it inside a lambda expression) it. Even though I've heard about it before I liked the reminder.
19. READ Case Study: Featherweight Java

Instead of modeling the object oriented concepts in simply typed lambda calculus as we did in chapter 18 (Imperative Objects) we'll know show how to use the ideas from previous chapter and implement them in Java directly.

The language that we will define is called Featherweight Java and is a small subset of Java that only consists of

• object creation
• method invocation
• type casting
• field access
• variables

As such it is very small and reasonably easy to reason about. The authors behind GJ (Generic Java, an implementation of generic programming in Java that ended up in Java 1.5) used FJ as the foundation and then enriched the language with generic classes and methods to become GJ.

A note on different type systems: the version that Java and many other mainstream languages is called nominal type system and works in the way that all information about a type is stored in the name of the type. As such a sub type relation is explicitly defined when defining the type (class or interface in Java). This is also the reason why it was impossible for a long time to have raw (anonymous) objects in Java. The research literature and languages that are included in the ML family, on the other hand, deals with structural type systems in which the the type names are not as essential as in nominal type systems since the type is defined on the structure of the object. This means that type names are simply aliases for the structural information of an object. The different type systems have their advantages and disadvantages which are discussed in the section 19.3.

21. WANT-TO-READ Metatheory of Recursive Types
25. WANT-TO-READ An ML Implementation of System F
27. WANT-TO-READ Case Study: Imperative Objects, Redux
28. WANT-TO-READ Metatheory of Bounded Quantification
29. WANT-TO-READ Type Operators and Kinding
32. WANT-TO-READ Case Study: Purely Functional Objects

### 2.14READING Verified Functional Programming in Agda   @study types logic programming functional @coding

Author(s): Aaron Stump @ The University of Iowa

The book is available to read online, through the Chalmers Library proxy: Verified Functional Programming in Agda

Agda is an advanced programming language based on Type Theory. Agda's type system is expressive enough to support full functional verification of programs, in two styles. In external verification, we write pure functional programs and then write proofs of properties about them. The proofs are separate external artifacts, typically using structural induction. In internal verification, we specify properties of programs through rich types for the programs themselves. This often necessitates including proofs inside code, to show the type checker that the specified properties hold. The power to prove properties of programs in these two styles is a profound addition to the practice of programming, giving programmers the power to guarantee the absence of bugs, and thus improve the quality of software more than previously possible.

Verified Functional Programming in Agda is the first book to provide a systematic exposition of external and internal verification in Agda, suitable for undergraduate students of Computer Science. No familiarity with functional programming or computer-checked proofs is presupposed.

The book begins with an introduction to functional programming through familiar examples like booleans, natural numbers, and lists, and techniques for external verification. Internal verification is considered through the examples of vectors, binary search trees, and Braun trees. More advanced material on type-level computation, explicit reasoning about termination, and normalization by evaluation is also included. The book also includes a medium-sized case study on Huffman encoding and decoding.

Review on: <2017-12-25 mån> [2017-09-13 ons 14:13]

#### 2.14.1[0%] Chapters

The first 5 chapters are suggested reading for the course DAT350 given at Chalmers.

Chapters:

• [-] 1. Functional Programming with the Booleans
• [X] 1.1 Declaring the Datatype of Booleans
• [X] 1.2 First Steps Interacting with Agda
• [X] 1.3 Syntax Declarations
• [X] 1.4 Defining Boolean Operations by Pattern Matching: Negation
• [X] 1.5 Defining Boolean Operations by Pattern Matching: And, Or
• [X] 1.6 The if-then-else Operation
• [X] 1.7 Conclusion
• [ ] Exercises
• [ ] 2. Introduction to Constructive Proof
• [ ] 2.1 A First Theorem about the Booleans
• [ ] 2.2 Universal Theorems
• [ ] 2.3 Another Example, and More On Implicit Arguments
• [ ] 2.4 Theorems with Hypotheses
• [ ] 2.5 Going Deeper: Curry-Howard and Constructivity
• [ ] 2.6 Further Examples
• [ ] 2.7 Conclusion
• [ ] Exercises
• [ ] 3. Natural Numbers
• [ ] 3.1 Peano Natural Numbers
• [ ] 3.2 Addition
• [ ] 3.3 Multiplication
• [ ] 3.4 Arithmetic Comparison
• [ ] 3.5 Even/Odd and Mutually Recursive Definitions
• [ ] 3.6 Conclusion
• [ ] Exercises
• [ ] 4. Lists
• [ ] 4.1 The List Datatype and Type Parameters
• [ ] 4.2 Basic Operations on Lists
• [ ] 4.3 Reasoning about List Operations
• [ ] 4.4 Conclusion
• [ ] Exercises
• [ ] 5. Internal Verification
• [ ] 5.1 Vectors
• [ ] 5.2 Binary Search Trees
• [ ] 5.3 Sigma Types
• [ ] 5.4 Braun Trees
• [ ] 5.5 Discussion: Internal vs. External Verification
• [ ] 5.6 Conclusion
• [ ] Exercises
• [ ] 6. Type-Level Computation
• [ ] 6.1 Integers
• [ ] 6.2 Formatted Printing
• [ ] 6.3 Proof by Reflection
• [ ] 6.4 Conclusion
• [ ] Exercises
• [ ] 7. Generating Agda Parsers with gratr
• [ ] 7.1 A Primer on Grammars
• [ ] 7.2 Generating Parsers with gratr
• [ ] 7.3 Conclusion
• [ ] Exercises
• [ ] 8. A Case Study: Huffman Encoding and Decoding
• [ ] 8.1 The Files
• [ ] 8.2 The Input Formats
• [ ] 8.3 Encoding Textual Input
• [ ] 8.4 Decoding Encoded Text
• [ ] 8.5 Conclusion
• [ ] Exercises
• [ ] 9. Reasoning About Termination
• [ ] 9.1 Termination Proofs
• [ ] 9.2 Operational Semantics for SK Combinators
• [ ] 9.3 Conclusion
• [ ] Exercises
• [ ] 10. Intuitionistic Logic and Kripke Semantics
• [ ] 10.1 Positive Propositional Intuitionistic Logic (PPIL)
• [ ] 10.2 Kripke Structures
• [ ] 10.3 Kripke Semantics for PPIL
• [ ] 10.4 Soundness of PPIL
• [ ] 10.5 Completeness
• [ ] 10.6 Conclusion
• [ ] Exercises

### 2.15WANT-TO-READ Software Foundations   @study programming logic @coding

The principal novelty of the series is that every detail is one hundred percent formalized and machine-checked: the entire text of each volume, including the exercises, is literally a "proof script" for the Coq proof assistant.

The exposition is intended for a broad range of readers, from advanced undergraduates to PhD students and researchers. No specific background in logic or programming languages is assumed, though a degree of mathematical maturity is helpful. A one-semester course can expect to cover Logical Foundations plus most of Programming Language Foundations or Verified Functional Algorithms, or selections from both.

### 2.16WANT-TO-READ Build Your Own Lisp   functional programming lisp c parser repl

Abstract: If you're looking to learn C, or you've ever wondered how to build your own programming language, this is the book for you.

In just a few lines of code, I'll teach you how to use C, and together, we'll start building your very own language.

Along the way we'll learn about the weird and wonderful nature of Lisps, how to develop a real-world project, concisely solve problems, and write beautiful code!

This book is free to read online, so you can get started right away! But for those who want to show their support, or who want the best reading experience, this book is also available for purchase in print format, or for cheap in all major e-book formats.

Available online here.

Author(s): Daniel Holden Review on: <2018-10-09 tis> Captured [2017-10-09 mån 19:31]

### 2.17WANT-TO-READ Land Of Lisp   programming functional programming lisp

Abstract: Lisp has been hailed as the world’s most powerful programming language, but its cryptic syntax and academic reputation can be enough to scare off even experienced programmers. Those dark days are finally over—Land of Lisp brings the power of functional programming to the people!

With his brilliantly quirky comics and out-of-this-world games, longtime Lisper Conrad Barski teaches you the mysteries of Common Lisp. You’ll start with the basics, like list manipulation, I/O, and recursion, then move on to more complex topics like macros, higher order programming, and domain-specific languages. Then, when your brain overheats, you can kick back with an action-packed comic book interlude!

Along the way you’ll create (and play) games like Wizard Adventure, a text adventure with a whiskey-soaked twist, and Grand Theft Wumpus, the most violent version of Hunt the Wumpus the world has ever seen.

You'll learn to:

• Master the quirks of Lisp’s syntax and semantics
• Write concise and elegant functional programs
• Use macros, create domain-specific languages, and learn other advanced Lisp techniques
• Create your own web server, and use it to play browser-based games
• Put your Lisp skills to the test by writing brain-melting games like Dice of Doom and Orc Battle

With Land of Lisp, the power of functional programming is yours to wield.

Author(s): Conrad Barski Review on: <2018-10-09 tis>

Abstract: This is a collection of short stories from the master of space opera. Peter Hamilton takes us on a journey from a murder mystery in an alternative Oxford in the 1800s to a story featuring Paula Mayo, deputy director of the Intersolar Commonwealth's Serious Crimes Directorate.

Author: Peter F Hamilton Review on: <2017-12-01 fre>

### 2.19WANT-TO-READ Clojure for the Brave and True   lisp clojure programming functional programming

Abstract: Do you want to learn Clojure, the most powerful and fun programming language on the planet? Do you want to unravel the mysteries of Lisp and functional programming? Do you want to punch hobbits and track down glittery vampires? Then you need to read this book!

Clojure’s popularity continues to grow, with companies like Netflix using it to build everything from complex, distributed systems to simple microservices to user interfaces. In Clojure for the Brave and True, you'll learn to wield this awesome language to its fullest!

Available online here.

Author(s): Daniel Higginbotham Review on: <2018-10-09 tis> [2017-10-09 mån 19:49]

### 2.21WANT-TO-READ Malazan Book of the Fallen

Algebra: Chapter 0 is a self-contained introduction to the main topics of algebra, suitable for a first sequence on the subject at the beginning graduate or upper undergraduate level. The primary distinguishing feature of the book, compared to standard textbooks in algebra, is the early introduction of categories, used as a unifying theme in the presentation of the main topics. A second feature consists of an emphasis on homological algebra: basic notions on complexes are presented as soon as modules have been introduced, and an extensive last chapter on homological algebra can form the basis for a follow-up introductory course on the subject. Approximately 1,000 exercises both provide adequate practice to consolidate the understanding of the main body of the text and offer the opportunity to explore many other topics, including applications to number theory and algebraic geometry. This will allow instructors to adapt the textbook to their specific choice of topics and provide the independent reader with a richer exposure to algebra. Many exercises include substantial hints, and navigation of the topics is facilitated by an extensive index and by hundreds of cross-references.

Author: Paolo Aluffi

A book on convex optimization problems and the mathematical background on them.

Authors: Stephen Boyd, Lieven Vandenberghe

Convex optimization problems arise frequently in many different fields. This book provides a comprehensive introduction to the subject, and shows in detail how such problems can be solved numerically with great efficiency. The book begins with the basic elements of convex sets and functions, and then describes various classes of convex optimization problems. Duality and approximation techniques are then covered, as are statistical estimation techniques. Various geometrical problems are then presented, and there is detailed discussion of unconstrained and constrained minimization problems, and interior-point methods. The focus of the book is on recognizing convex optimization problems and then finding the most appropriate technique for solving them. It contains many worked examples and homework exercises and will appeal to students, researchers and practitioners in fields such as engineering, computer science, mathematics, statistics, finance and economics.

The book is available here.

For some time now I’ve been floating the idea of writing a book about category theory that would be targeted at programmers. Mind you, not computer scientists but programmers — engineers rather than scientists. I know this sounds crazy and I am properly scared. I can’t deny that there is a huge gap between science and engineering because I have worked on both sides of the divide. But I’ve always felt a very strong compulsion to explain things. I have tremendous admiration for Richard Feynman who was the master of simple explanations. I know I’m no Feynman, but I will try my best. I’m starting by publishing this preface — which is supposed to motivate the reader to learn category theory — in hopes of starting a discussion and soliciting feedback.

Author(s): Bartosz Milewski Review on: <2018-08-31 fre>

### 2.25WANT-TO-READ Pragmatic Programmer   quality code oscar programming

Straight from the programming trenches, The Pragmatic Programmer: From Journeyman to Master cuts through the increasing specialization and technicalities of modern software development to examine the core process—what do you do, as an individual and as a team, if you want to create software that’s easy to work with and good for your users.

This classic title is regularly featured on software development “Top Ten” lists, and is issued by many corporations to new hires.

Author(s): David Thomas & Andrew Hunt Review on: <2018-09-03 mån> Books [2018-08-13 mån 13:30]

### 2.26WANT-TO-READ Release It   oscar programming software quality code

Whether it's in Java, .NET, or Ruby on Rails, getting your application ready to ship is only half the battle. Did you design your system to survivef a sudden rush of visitors from Digg or Slashdot? Or an influx of real world customers from 100 different countries? Are you ready for a world filled with flakey networks, tangled databases, and impatient users?

If you're a developer and don't want to be on call for 3AM for the rest of your life, this book will help.

In Release It!, Michael T. Nygard shows you how to design and architect your application for the harsh realities it will face. You'll learn how to design your application for maximum uptime, performance, and return on investment.

Author(s): Michael T. Nygard Review on: <2018-10-15 mån>

### 2.27WANT-TO-READ Site Reliability Engineering   oscar programming software system

The overwhelming majority of a software system’s lifespan is spent in use, not in design or implementation. So, why does conventional wisdom insist that software engineers focus primarily on the design and development of large-scale computing systems?

In this collection of essays and articles, key members of Google’s Site Reliability Team explain how and why their commitment to the entire lifecycle has enabled the company to successfully build, deploy, monitor, and maintain some of the largest software systems in the world. You’ll learn the principles and practices that enable Google engineers to make systems more scalable, reliable, and efficient—lessons directly applicable to your organization.

This book is divided into four sections:

• Introduction — Learn what site reliability engineering is and why it differs from conventional IT industry practices
• Principles — Examine the patterns, behaviors, and areas of concern that influence the work of a site reliability engineer (SRE)
• Practices — Understand the theory and practice of an SRE’s day-to-day work: building and operating large distributed computing systems
• Management — Explore Google's best practices for training, communication, and meetings that your organization can use

Author(s): Niall Richard Murphy Review on: <2018-11-05 mån>

Author: Frank Herbert

This book is a real classic in sci-fi and rightly so! I made a quite short and uninspiring review on Goodreads a while ago

I really like Dune, specifically the idea of a far-off future with a galactic aristocracy, where feudal lords preside over their planets. This combination of new and old is a very intriguing setting for a story and lends itself well for interesting power struggles between the ruling houses.

and even though it sure as heck deserves more than what I gave it I never got around to improve my review.. Maybe I'll do that some day.

Author: Hugh Howey

### 2.31READING The Rust Programming Language   functional programming rust programming language @coding

It wasn’t always so clear, but the Rust programming language is fundamentally about empowerment: no matter what kind of code you are writing now, Rust empowers you to reach farther, to program with confidence in a wider variety of domains than you did before.

Author(s): Nicholas Matsakis and Aaron Turon Review on: <2019-06-01 lör>

### 2.32WANT-TO-READ Linux Programming Interface   programming oscar OS linux

The Linux Programming Interface (TLPI) is the definitive guide to the Linux and UNIX programming interface—the interface employed by nearly every application that runs on a Linux or UNIX system.

In this authoritative work, Linux programming expert Michael Kerrisk provides detailed descriptions of the system calls and library functions that you need in order to master the craft of system programming, and accompanies his explanations with clear, complete example programs.

Author(s): Michael Kerrisk Review on: <2019-07-08 mån> Link to book [2019-01-23 ons 12:26]

I will never forget the day my family got cut off from the Internet. I was hiding in my room as I usually did after school let out, holed up with a laptop I'd bought third-hand and that I nursed to health with parts from here and there and a lot of cursing and sweat.

But that day, my little lappie was humming along, and I was humming with it, because I was about to take away Scot Colford's virginity.

You know Scot Colford, of course. They've been watching him on telly and at the cinema since my mum was a girl, and he'd been dead for a year at that point. But dead or not, I was still going to take poor little Scoty's virginity, and I was going to use Monalisa Fiore-Oglethorpe to do it.

Author: Robert Nystrom

This may be the beginning of a grand adventure. Programming languages encompass a huge space to explore, play in, and perhaps carve out your own territory where you build something new for others to use. Brilliant computer scientists and software engineers have spent entire careers traversing this land without ever reaching the end. If this book is your first entry into the country, welcome.

The pages of this book give you a guided tour through a corner of the world of languages. But before we strap on our hiking boots and venture out, we should familiarize ourselves with the territory. The chapters in this part introduce you to the basic concepts used by programming languages and how they are organized.

We will also get acquainted with Lox, the language we’ll spend the rest of the book implementing (twice). Let’s go!

## 3 Blog entries

These blog posts are blog posts that I've stumbled upon while trying to grasp subjects while studying or linked material in youtube talks or similar stuff.

It will probably stay rather technical, but that is more a guess than a promise.

Read blog posts are found in the archive.

### 3.1WANT-TO-READ Lenses in Swift   article programming functional programming

Lenses are awesome and cool! Here is an article about it that will hopefully give me some intuition!

Laziness in Haskell is possibly one of it's coolest features and enables us to code up functions that handle infinte data, bottoms or other potentially dangerous stuff.

Simon Marlow wrote an article about their work with fighting spam at Facebook. What makes this very interesting is that Simon Marlow is a kind of reknown Haskell person and that he was hired by Facebook to do some fancy Haskell stuff.

Stephen Diehl wrote an article about stuff he wish he knew when he first learnt Haskell. This could be very interesting to read about, especially now that I know some Haskell.

The continuation monad is one of the least appreciated monads and in this post I hope to motivate when to use it. This post will first motivate continuations in general and then motivate them in their specific capacity as monads.

### 3.6WANT-TO-READ Category theory for programmers   programming computer science

Bartosz Milewski has written a serie of blog posts explaining Category theory for people that has some experience in programming. I think category theory is fascinating, but I can't handle all the math needed to understand it without putting it together with some familiar contexts so this blog serie is probably for me.

### 3.7WANT-TO-READ What every CS major should know   computer science programming

A blog post about what every computer science student should know.

A blog post about test-driven development.

A reflection on the Haskell year of 2017 by Stephen Diehl.

### 3.10WANT-TO-READThe Absolute Minimum Every Software Developer Must Know About Unicode and Character Sets

Linked to by Hello my name is Joël by nerderati.com.

### 3.11WANT-TO-READAn Introduction to Recursion Schemes

In 1991, Erik Meijer, Maarten Fokkinga, and Ross Paterson published their now-classic paper Functional Programming with Bananas, Lenses, Envelopes and Barbed Wire. Though this paper isn’t widely known outside of the functional programming community, its contributions are astonishing: the authors use category theory to express a set of simple, composable combinators, called recursion schemes, that automate the process of traversing and recursing through nested data structures. Though recursion schemes predate Meijer et. al’s work, this paper brings the enormous abstractive power of category theory to bear on the subject of traversing data structures—it’s a magnificent example of how category-theoretical concepts can bring both rigor and simplicity to day-to-day programming tasks.

### 3.12WANT-TO-READFunctional options for friendly APIsgo @work @coding

Captured 2018-07-25 18:13

What follows is the text of my presentation, Functional options for friendly APIs that I gave at dotGo this year. It has been edited slightly for readability.

I want to thank Kelsey Hightower, Bill Kennedy, Jeremy Saenz, and Brian Ketelsen, for their assistance in preparing this talk.

### 3.13WANT-TO-READGo modulesversioning go @work @coding

A walkthrough of the soon-to-be released vgo.

### 3.14WANT-TO-READDon’t just check errors, handle them gracefullyerror handling go @work @coding

Errors are just values I’ve spent a lot of time thinking about the best way to handle errors in Go programs. I really wanted there to be a single way to do error handling, something that we could teach all Go programmers by rote, just as we might teach mathematics, or the alphabet.

However, I have concluded that there is no single way to handle errors. Instead, I believe Go’s error handling can be classified into the three core strategies.

### 3.15WANT-TO-READPortable Cloud Programming with Go Cloudcloud go @work @coding

Today, the Go team at Google is releasing a new open source project, Go Cloud, a library and tools for developing on the open cloud. With this project, we aim to make Go the language of choice for developers building portable cloud applications.

This post explains why we started this project, the details of how Go Cloud works, and how to get involved.

### 3.16WANT-TO-READ Increment and Decrement Integer at Point   emacs elisp

While editing you often have to increment or decrement some number (usually an integer) by some step. Obviously this is trivial when the number is something like 10, but not pretty pleasant when the number is 2343566 and you want to increment it by 943. Most of the time, however, you’ll probably be incrementing or decrementing by 1.

Author(s): Bozhidar Batsov

### 3.17WANT-TO-READ The Laws of Reflection   go programming code

Reflection in computing is the ability of a program to examine its own structure, particularly through types; it's a form of metaprogramming. It's also a great source of confusion.

Author(s): Rob Pike

### 3.18WANT-TO-READ Go Data Structures: Interfaces   go code programming

Go's interfaces—static, checked at compile time, dynamic when asked for—are, for me, the most exciting part of Go from a language design point of view. If I could export one feature of Go into other languages, it would be interfaces.

This post is my take on the implementation of interface values in the “gc” compilers: 6g, 8g, and 5g. Over at Airs, Ian Lance Taylor has written two posts about the implementation of interface values in gccgo. The implementations are more alike than different: the biggest difference is that this post has pictures.

Before looking at the implementation, let's get a sense of what it must support.

Author(s): Russ Cox

A reading list for those interested in the implementation internals of Haskell compilers. The GHC Reading list is more exhaustive, these are simply the papers I think give a good high-level overview of the topics.

A copy of all of the PDF papers is available in this Git repo.

### 3.20WANT-TO-READA Purely Functional Typed Approach to Trainable Modelsml fp programming functional haskell

With the release of backprop, I’ve been exploring the space of parameterized models of all sorts, from linear and logistic regression and other statistical models to artificial neural networks, feed-forward and recurrent (stateful). I wanted to see to what extent we can really apply automatic differentiation and iterative gradient decent-based training to all of these different models. Basically, I wanted to see how far we can take differentiable programming (a la Yann LeCun) as a paradigm for writing trainable models.

Building on other writers, I’m starting to see a picture unifying all of these models, painted in the language of purely typed functional programming. I’m already applying these to models I’m using in real life and in my research, and I thought I’d take some time to put my thoughts to writing in case anyone else finds these illuminating or useful.

### 3.2124 days of Hackage, 2015: day 7: semigroups; NonEmpty list and a case study of types and tests

Found this while searching for interesting articles about XML in Haskell. Captured On: [2017-10-24 tis 15:58]

## 4 Short stories

These short stories are either stories I am currently reading or stories that are recommended to me, or work of authors I appreciate.

As with the other work of literature I've consumed, read short stories are found in the archive.

### 4.1WANT-TO-READ The Colour out of Space   short story cthulhu lovecraft fiction

Author: H.P Lovecraft

I want to start to read some H.P Lovecraft, it is apparently some kind of cult literature and basis of some internet culture and I figure it is probably wise to not be completely ignorant of it.

This short story was recommended to me to start with, then I might continue with other short stories on the same site.

Created: 2020-04-15 ons 23:16

Validate