Reading archive

A glimpse of my past reading habits

Archived entries from

1 Articles

1.1 READ DSL for the uninitiated   programming functional programming article

An article about how to use DSL's as a communication bridge between developers and business users to boost collaboration.

1.1.1 About the article

Author: Debashish Ghosh Journal: Communications of the ACM, Vol 54 No. 7: 44-50, July 2011

Link to paper

1.2 READ A Poor Man's Concurrency Monad

Author: Koen Classen

Abstract: "Without adding any primitives to the language, we define a concurrency monad transformer in Haskell. This allows us to add a limited form of concurrency to any existing monad. The atomic actions of the new monad are lifted actions of the underlying monad. Some extra operations, such as fork, to initiate new processes, are provided. We discuss the implementation, and use some examples to illustrate the usefulness of this construction."

Link to paper

1.3 READ Runtime Support for Multicore Haskell

Authors: Simon Marlow, Simon Peyton Jones, and Satnam Singh.

Abstract: "Purely functional programs should run well on parallel hardware because of the absence of side effects, but it has proved hard to realise this potential in practice. Plenty of papers describe promis- ing ideas, but vastly fewer describe real implementations with good wall-clock performance. We describe just such an implementation, and quantitatively explore some of the complex design tradeoffs that make such implementations hard to build. Our measurements are necessarily detailed and specific, but they are reproducible, and we believe that they offer some general insights."

An overview of GHC's parallel runtime, lots of optimisations, and lots of measurements.

Link to paper (currently read to p. 6)

1.4 READ Paxos Made Simple   distributed systems

Author(s): Leslie Lamport

Abstract: At the PODC 2001 conference, I got tired of everyone saying how difficult it was to understand the Paxos algorithm, published in [122]. Although people got so hung up in the pseudo-Greek names that they found the paper hard to understand, the algorithm itself is very simple. So, I cornered a couple of people at the conference and explained the algorithm to them orally, with no paper. When I got home, I wrote down the explanation as a short note, which I later revised based on comments from Fred Schneider and Butler Lampson. The current version is 13 pages long, and contains no formula more complicated than n1 > n2.

Link to paper

1.5 READ How to Read a Paper

Author: S. Keshav

Abstract: Researchers spend a great deal of time reading research papers. However, this skill is rarely taught, leading to much wasted effort. This article outlines a practical and efficient three-pass method for reading research papers. I also describe how to use this method to do a literature survey

Link to paper

1.6 READ Haskell on a shared-memory multiprocessor

Authors: Tim Harris, Simon Marlow, Simon Peyton Jones. The first paper on multicore Haskell.

Abstract: "Multi-core processors are coming, and we need ways to program them. The combination of purely-functional programming and explicit, monadic threads, communicating using transactional memory, looks like a particularly promising way to do so. This paper describes a full-scale implementation of shared-memory parallel Haskell, based on the Glasgow Haskell Compiler. Our main tech- nical contribution is a lock-free mechanism for evaluating shared thunks that eliminates the major performance bottleneck in paral- lel evaluation of a lazy language. Our results are preliminary but promising: we can demonstrate wall-clock speedups of a serious application (GHC itself), even with only two processors, compared to the same application compiled for a uniprocessor."

Link to paper

1.7 READ Feedback directed implicit parallelism

Authors: Tim Harris and Satnam Singh.

Abstract: "In this paper we present an automated way of using spare CPU re- sources within a shared memory multi-processor or multi-core ma- chine. Our approach is (i) to profile the execution of a program, (ii) from this to identify pieces of work which are promising sources of parallelism, (iii) recompile the program with this work being performed speculatively via a work-stealing system and then (iv) to detect at run-time any attempt to perform operations that would reveal the presence of speculation.

We assess the practicality of the approach through an implementation based on GHC 6.6 along with a limit study based on the execution profiles we gathered. We support the full Concurrent Haskell language compiled with traditional optimizations and including I/O operations and synchronization as well as pure computation. We use 20 of the larger programs from the ‘nofib’ bench- mark suite. The limit study shows that programs vary a lot in the parallelism we can identify: some have none, 16 have a potential 2x speed-up, 4 have 32x. In practice, on a 4-core processor, we get 10-80% speed-ups on 7 programs. This is mainly achieved at the addition of a second core rather than beyond this.

This approach is therefore not a replacement for manual parallelization, but rather a way of squeezing extra performance out of the threads of an already-parallel program or out of a program that has not yet been parallelized."

Link to paper

1.8 READ Runtime Support for Multicore Haskell   programming functional haskell

Author(s): Simon Marlow, Simon Peyton Jones, Satnam Singh

Abstract: Purely functional programs should run well on parallel hardwarebecause of the absence of side effects, but it has proved hard torealise this potential in practice. Plenty of papers describe promis-ing ideas, but vastly fewer describe real implementations with goodwall-clock performance. We describe just such an implementation,and quantitatively explore some of the complex design tradeoffsthat make such implementations hard to build. Our measurementsare necessarily detailed and specific, but they are reproducible, andwe believe that they offer some general insights.

Link to paper

2 Books

2.1 READ Colour of Magic   discworld fantasy book

The first book in the Discworld universe.

Introduces the Discworld to the reader and explains a lot of how the life is lead on the disc. Also introduces the reader to the characters Rincewind, Twoflower and the luggage, as well as the city of Ankh-Mopork and its citizens.

Twoflower is a citizen from the Counterweight Continent (which is called so because it serve as a counterweight to the known continent and keeps the disc balanced), where gold is so common it is more or less worthless. Twoflower usually has a difficult time adjusting to the fact that gold on the known continent actually is really valuable and this is not helped by Rincewind's (a student of the Unseen Academy and also his sworn protector and guide) interest in earning money.

Great book to start the Discworld adventure with. The story is continued in The Light Fantastic.

2.2 READ The Light Fantastic   discworld fantasy book

The second book in the Discworld universe and successor of Colour of Magic.

In this book we follow Rincewinds continued attempts to protect Twoflower (the first tourist on the disc) as he visits the different parts of the known continent. They experience a lot of adventures as they traverse the continent in search for moments to capture with the iconograph (a small machine-like box, in which an imp is painting the world as he sees it from the lens).

It seems that the new Archmage of the Unseen Academy is interested in controlling the eight creator spells, one of which is stuck inside Rincewinds head (and is the reason why he has not learned even the simplest spell), how will this end?

Also a great book, continues from where Colour of Magic ended.

2.3 READ Learn You a Haskell For a Great Good   functional programming haskell @study

The book is available to read online: Learn You a Haskell book

I decided to write this because I wanted to solidify my own knowledge of Haskell and because I thought I could help people new to Haskell learn it from my perspective. There are quite a few tutorials on Haskell floating around on the internet. When I was starting out in Haskell, I didn't learn from just one resource. The way I learned it was by reading several different tutorials and articles because each explained something in a different way than the other did. By going through several resources, I was able put together the pieces and it all just came falling into place. So this is an attempt at adding another useful resource for learning Haskell so you have a bigger chance of finding one you like.

2.3.1 Thoughts

The book is actually rather easy to read and contains helpful allegories and examples to make the underlying intuition understandable.

It might not be the best book for learning Haskell, but it is a free resource and worth a read.

Especially for me, after using it as a course literature in our introductory Haskell course and then coming back to it after a few years, the chapters on Functors, Applicatives, Monads and Zippers contained food for thought and helped me cement the concepts even more.

3 Blog entries

3.1 READ The Rise of the Weaponized AI Propaganda Machine   democracy computer science ai politics

There’s a new automated propaganda machine driving global politics. How it works and what it will mean for the future of democracy.

Link to blog post

4 Short stories

Author: Jassob

Created: 2020-04-15 ons 23:16