Contrast a book with a movie, for instance. The information a book contains is certainly more abstract than the information a movie rams into my head. I don’t know how Naoko in Norwegian Wood looked like but Martha always conjures up the image of Helena Bontham Carter in a hat, smoking a freshly lit cigarette. Naoko‘s image is malleable and ethereal but Martha will always be a dark girl with curly hair (this is not to criticize Fight Club, I loved the movie).

I think this makes books more relatable, and a well written text hits me at a very base level. Since the written word is so flexible and abstract, my mind can lift it up to a concrete representation that is very close to my sense of self. A book can drive me to insanity, a movie cannot.

I think the same applies to music too — I’ve always found solos by Pink Floyd their most interesting work. When a rapper talks about how he “hit it up with a ho” (I’m not good with american street slang so I just made that up), there is only so much information my mind can add, there is only so much I can misinterpret. When I hear the crazy slide-guitar in Shine on you crazy diamond, VI-IX, my mind is forced to conjure up something using the only tools it has at its disposal, my imagination and my experience. And it always comes up with something sinister.

What Glaucon says next seemed a lot like Rawls’ theory of a social contract (I have not read Rawls’ work in detail, and might be standing on mount stupid). The case for justice, he says, is that the pain of suffering injustice outweighs the pleasure of committing it. Hence, we “find it expedient to make a compact of mutual abstinence from injustice” and that “there is certainly no one else who is willingly just; but it is from cowardice, or age, or some other infirmity, that men condemn injustice [...] this is proved by the fact that the first of these people who comes to power is the first to commit injustice”

Glaucon then goes on to compare the ideal just man and the ideal unjust man. In fact, he makes the distinction between being just and the appearance of being just — if Socrates defends a just man who is known for his justice, he is not defending justice but merely its appearance. The ideal just man has the worst reputation for injustice, he says, without being guilty of a single unjust act; and the ideal unjust man is the opposite. It is easy to see how such an ideal unjust man will trump the ideal just man in every situation; he sums it up by saying “to be just without also thought just is no advantage to me, but only entails manifest trouble and loss, whereas if I am unjust and get myself a name for justice an unspeakably happy life is promised me”.

One deterrent to injustice is the promise of afterlife — people who have lived just and honest lives spend eternity carousing with the gods while the ungodly and unjust are plunged into Hades, condemned to carry water in a sieve. However, there is no shortage of soothsayers and quacks who claim to have powers to amend crimes committed in this world — unjust people (who are usually rich enough to afford such luxuries) tend to hire such people to insure their afterlife. Such practices are further encouraged by poets like Homer, Glaucon says, by spreading stories how not just individuals but whole cities can petition a god’s forgiveness by offering the right sacrifice.

It does not seem like (not to me, at least) that Socrates actually makes a proper attempt to address the concern (that the unjust man is always better off than the just man), but diverges to another direction entirely. He starts the discussion by talking about justice in a city; hoping to get some helpful insight into the nature of justice. He first talks about specialization. Once the basic needs of the citizens are met, need will be felt to “cut ourselves a slice of our neighbour’s territory” for greater luxury and comfort. This adds another specialization that a healthy city needs — warriors, or guardians. These guardians needs to be gentle to their friends and dangerous to their enemies. This way, I think, Socrates links the qualities of the warriors to that of a just man, as discussed in book one.

I find the next argument (primarily by Socrates) very absurd. Firstly, they somehow convince themselves that a high-spirited gentle man is a contradiction. Socrates resolves this contradiction by comparing such a man with a dog; and noting that a dog equates acquaintance with friendship and “How, I ask, can the creature be other than fond of learning when it makes knowledge and ignorance the criteria of the familiar and the strange?”. This is clearly well-fermented manure — in fact, that a dog refuses to use any other (more reliable) criterion to judge animosity and friendship shows that it is not fond of learning and self-correction. Even if you disregard the absurdity of this argument, there is no way such a predicate can be literally translated over to a human. The comparison of human and animal behaviour in most contexts is dubious at best and in my opinion, breaks down completely when you try to draw such sweeping conclusions.

Anyway, once they’ve concluded that the nature of the guardians are supposed to be “philosophical, high-spirited, swift-footed and strong”, the focus goes to their education. Socrates has something against the poet-educated culture (he definitely has reason to :)) and suggests a censor on the kind of folklore a future guardian is exposed to in his childhood. Socrates is concerned that exposure to folklore that depict gods and other respectable engage in immoral, unjust behaviour, sets a bad example for children to aspire to. He gives various examples I won’t repeat.

Book two ends with Socrates arguing that since

• gods are perfect beings
• gods can only change their form only by exerting their own will
• the human form is imperfect

they never impose themselves on us by sending signs, apparitions or by appearing in our dreams. Doing so would involve debasing themselves, which no god would ever do. This is a clear case against poets who often use gods as characters in their storytelling. He says when “a poet uses such language concerning the gods, we shall be angry with him and refuse him a chorus, neither shall we allow our teachers to use his writing for the instruction of the young”. The rift between the philosophers and the poets is clearly visible at this point.

The first book begins by Socrates talking about old age with Cephalus and whether wealth has any role in keeping one happy in old age. Cephalus says that wealth helps one remain just. Since old people tend to worry more about afterlife (because death is now imminent) and the repercussions of being immoral play out in afterlife, wealth in general contributes to happiness in old age. This steers the conversation towards discussing what is meant by being just.

Socrates says it can’t merely be returning to people what they owe you — you would not return a knife a friend lent you when your friend is mad with rage (and likely to do something rash). Polemarchus takes up this argument and says (quoting Simonides) that debt of friend to friend is to do good to one another and not harm. Then Socrates goes on to conclude that justice is useless when a thing is in use, but useful when it is out of use. I personally could not follow this argument — Socrates says, for instance, “well, in what partnership is the just man superior to the harp player?”. The point being missed, I think, is that justness and the ability to play a harp are not exclusive properties. You can be a just harp player (in which case you’ll wrong your enemies and help your friends) or an unjust one; and your justness has nothing to do with your harp playing, like the wetness of an apple has nothing to do with its redness.

Moreover, Socrates says, a person is likely to make a mistake or two in choosing his friends. He might end up regarding a good, just person an enemy and a thieving, malicious person as a friend. And now if he follows the doctrine of hurting his enemies and helping his friends, he’ll end up doing something that is clearly wicked.

Hearing this, Polemarchus makes a change to his definition of justice, changing it to mean hurting enemies who are bad and helping friends who are good. Again Socrates goes into an argument which my spoonful of cognition can’t decipher. He concludes by saying that justice, by its virtue of justness can not make other people unjust. But, since hurting anyone makes them less excellent in human virtues and since justice is a human virtue; justice, but justness can not hurt anyone. I have two problems with this argument.

First is with the conclusion: if being just implies hurting no-one, it only cements Thrasymachus’s argument that will appear later. The second is with the actual argument: Socrates asks, for instance, “can musicians, by their art of music, make men unmusical?”. While Polemarchus answers no, I think yes. Specifically, I think it is a musician who has the most ability to render men unmusical; by using the art of music. The art of music itself does not have values. In fact, it has been agreed only pages before that “a man can guard expertly whatever he can thieve expertly” and that in cases of illness, a physician is the person who can do more harm to enemies and more good to friends.

After this, we see Thrasymachus in the scene. After a brief squabble with Socrates, he gives his view of justice: that it is the interest of the stronger. He talks about how rulers legislate laws which are in the interest of the rulers themselves. Socrates employs the pattern he just used, talking about how rulers are apt to make mistakes and legislate laws that are not in their favor. Is following those laws (which are not in the interest of the stronger) also just? Thrasymachus parries with the abstract concept of a ruler who does not make mistakes. A rules is not a ruler in the time he makes a mistake, just like a cook is not a cook at the time he forgets to season his dishes.

Then Socrates says that the art of ruling, in its highest form, is the art of taking care of the subjects being ruled. This implies that the rulers will end up legislating in interest of the people being ruled and not the rulers themselves. In fact, he says, the reason why people contest of government offices is not because they want power, but because they are averse to being ruled by an unjust man. Thrasymachus’s response is that while a shepherd tends to his sheep and has their interests in his mind; those interests stems from how he’ll harvest their wool and eat their meat later, not a genuine sense of service.

Before this argument proceeds further, Thrasymachus says something more important — that an unjust man is always better off than a just man. He gives reasons that are essentially obvious. Socrates has a bit of trouble arguing with this one. He finally ends the conversation with a teleological argument, saying that it is the property of the soul to be just and an unjust person cannot be better off than a just person since he is violating the very purpose of his soul. This argument did not make much sense to me.

In my opinion, the problem in book one is that justice is being considered a property of an individual, when it is the property of social structures. I see justice as a set of strategies which ensures a stable society — in principle, it is always more profitable for an individual to be unjust.

The Problem

Let’s say A is a runtime function that sometimes gets called by JIT compiled code. When the control is inside A, the stack may look something like this:

[  A  ]
[ Some JIT compiled function (X)  ]
[ Some other JIT compiled function (Y)  ]
[ Some function that launches JIT compiled code (B)  ]
[ Some function that does the JIT compilation (C)  ]
[   .... and so on ....  ]
[  First function for this thread == (D)  ]

Now, for GDB to be able to successfully unwind through the X and Y frames, it needs some extra information. For regular functions (like A, B, C and D) this information is embedded in a section in the ELF file, using the DWARF encoding. However, X and Y don’t have any such associated information since they were generated on the fly. On trying to backtrace when the stack is in the state shown above you’ll

• See a bunch of ??s instead of X and Y, since GDB does not have the debug symbols.
• A possibly incorrect backtrace. From what I understand, GDB can backtrace by interpreting the prologue, but only up to a point.

The initial solution (still supported by GDB) was this: whenever the JIT compiler compiles a block of code, have it emit the debug information to an ELF file in memory. Then have the JIT compiler notify GDB of these in-memory ELF files using a published interface. This way, GDB knows how to display a pretty backtrace.

This solution (of generating ELF files in memory) is, however, not ideal. ELF files are complex and hard to generate. Generating ELF files bites even more if all that GDB needs to do is display a meaningful stack trace. My job was to find a less complex way to get the debugging information into GDB.

The Solution

It was Tom Tromey’s idea that it probably makes more sense to load and use some sort of a plugin provided by the JIT vendors. I too thought this idea was viable and decided to implement it and see how well it worked.

The problem can be divided into two parts — providing the debug symbols and providing the unwind information. We don’t deal with providing type information and other such more sophisticated information, since we’re targeting people who just want to see a meaningful stack trace without putting in too much effort. The ELF handling code is still in GDB and anyone wishing to do something more exciting than looking at a backtrace can generate full-fledged ELF files.

For the debug symbols part, we

1. Have the JIT compiler generate the debug symbol information in any format it pleases. GDB does not need to understand this format.
2. Have the plugin parse this debug information (since it understands the format, being written by the JIT vendor) and emit the symbol tables GDB requires.

In the name of a clean interface and better backward compatibility, (2) is done by passing a bunch of callback functions to the plugin, along with the data it is supposed to parse (the data that the JIT compiler passed to GDB). The plugin then constructs the symbol tables using the callbacks it is given. There are callbacks to create a new symbol table (symtab_open), to add a mapping from line numbers to PCs (line_mapping_add) among others. All this is documented in the header jit-reader.h.

jit-reader.h is installed in {includdir}/gdb/, where {includedir} is the system’s default include directory. This header is the interface between the plugin and GDB, and needs to be included in the plugin source file. Because of where it is installed by default, usually a #include <gdb/jitreader.h> is sufficient.

For the unwinding part we simply have the plugin provide an unwinder. The unwinder too gets a bunch of callbacks, one to read the value of a register in the current frame, one to tell GDB (write) the value of a register in the previous frame (the one that was called immediately before), one to read some data off the target process’ address space, one to generate a frame id (described in jit-reader.h) and so on. The unwinder is especially easy to write if the JIT compiled code stores interesting things at constant offsets from the base register. Pseudo code could be

  READ_REGISTER(cb, AMD64_RBP, FramePtr);
  PreviousFP = READ_MEMORY_AT(FramePtr)
  PreviousPC = READ_MEMORY_AT(FramePtr + 8)

  WRITE_REGISTER(AMD64_RBP, PreviousFP)
  WRITE_REGISTER(AMD64_RA, PreviousPC)

Telling GDB the values of the frame pointer and the program counter is enough for it to display a backtrace.

I’ve checked in the code, and it is available in the current trunk. This was a very general bird’s eye view of the situation, more information can be found in the GDB manual and the jit-reader.h file GDB installs. Thanks to everyone on the GDB mailing list who sent in their valuable reviews.

Comments, suggestions and questions welcome.

Unlike Lisp’s macro system, TH is typed — like everything else in Haskell. You have typed constructors like FunD (function declaration) and InfixP which are used the build the AST of whatever form you wish to splice into your regular code. You can find the current TH user manual at [1].

The AST constructors are in the module Language.Haskell.TH, which looks quite overwhelming at the first glance, and, as such, writing TH expressions from scratch can get quite difficult. Thankfully, we also have a nice runQ function which allows us to write TH expressions without really grokking everything in the module. I’ll try to demonstrate this by getting TH to generate a small (read useless / toy) string matcher.

Objective

We’ll try to generate a function with the type String->Bool. The function’s job will be to check if the String it receives belongs to a list of Strings we provide at compile time. To make things a little more interesting, we’ll allow the strings we have at compile time to have a regex-like "?" in them, which can match any character. As an example, if the list of Strings is ["asdf", "a?foo", "P"], the generated function should match "asdf", "P", "amfoo" but not "afoo". We don’t address the issue of how to match a literal "?". Heck, out end product boils down to ten lines of code.

Once we’re done writing our TH code, we should have a function generateMatcher, which we shall invoke from the top level of a source file, like:

  generateMatcher "generatedF" ["asdf", "a?foo", "P"]

It will then generate the matcher, with the name generatedF and the behaviour we’re just described. It can then be called like a regular function. So a source file can look like:

  generateMatcher "generatedF" ["asdf", "a?foo", "P"]

  main = do
    str < - getLine
    putStrLn $ show $ generatedF str

Starting Off

The first thing to think about is how the compiled code should look like. Given the above problem instance, we could generate something like

    generatedF ('a':'s':'d':'f':[]) = True
    generatedF ('a':_:'f':'o':'o':[]) = True
    generatedF ('P':[]) = True
    generatedF _ = False
  

Haskell’s pattern matcher is, AFAIK, intelligent enough to convert the cases into a tree structure and quickly jump to the correct clause. Now the second question: how should the AST look like? Here we take the help of the runQ function. First we start GHCi as ghci -XTemplateHaskell (since TH is not enabled by default). Once in GHCi, we import the required module by :m + Language.Haskell.TH. The scene is set! We can now see the AST for generatedF ('a':'s':'d':'f':[]) = True. For that, we evaluate runQ [d|generatedF ('a':'s':'d':'f':[]) = True|]. The [d| ... |] is used to quote a declaration. Detailed information (about this, and generally about TH) is in [1]. We will now see some (rather incomprehensible) output:

[FunD generatedF [Clause [InfixP (LitP (CharL 'a'))
GHC.Types.: (InfixP (LitP (CharL 's')) GHC.Types.:
(InfixP (LitP (CharL 'd')) GHC.Types.:
(InfixP (LitP (CharL 'f')) GHC.Types.:
(ConP GHC.Types.[] []))))] (NormalB
(ConE GHC.Bool.True)) []]]

A little indentation, of course, goes a long way in making things clearer (when does it not? :D):

[FunD
 generatedF [Clause
             [InfixP (LitP (CharL 'a'))
              GHC.Types.:
              (InfixP (LitP (CharL 's'))
               GHC.Types.:
               (InfixP (LitP (CharL 'd'))
                GHC.Types.:
                (InfixP (LitP (CharL 'f'))
                 GHC.Types.:
                 (ConP GHC.Types.[] []))))]
             (NormalB (ConE GHC.Bool.True)) []]]
  

I usually use guesswork from this point, leaving it to Haskell’s type system to correct my incompetence. Haskell’s AST has the convention of suffixing most data constructors with a letter which hints at what type it belongs to. We can guess (and purely guess, I have not looked up the documentation) that InfixP is an infix pattern, a LitP is a literal pattern, a NormalB is a normal body, a ConE is a constructor expression, a FunD is a function declaration and so forth. The AST for the match-anything clause is simpler:

  [FunD
   generatedF [Clause [WildP]
               (NormalB (ConE GHC.Bool.False)) []]]

You can guess what a WildP is, especially since it derives from a _.

The core idea

The basic idea behind TH is that allowing the user to splice in a bit of custom-generated AST into an otherwise normal Haskell program can lead to all kinds of awesomeness. A splicable AST has to be typed as a Q Exp, a Q Type or a Q [Dec]. The last one stands for a list of declarations, which is the one we need right now. To splice in an expression as an AST, we place it inside a $( ... ). To keep things clean, top level declarations don’t need the $( ... ) nesting — anything of the type Q [Dec] at the top level of a source file is automatically interpreted correctly. Q is a Monad, which is sometimes needed to generate unique identifiers, like Lisp’s gensym. We don’t need that right now.

Getting back to the point, we need a function that takes the specified input, and outputs the AST of the code we want to generate. Since we need to generate something of the type Q [Dec], and we will be given the name of the function to generate, and a list of Strings, there is at least one line we can write:

  generateMatcher :: String -> [String] -> Q [Dec]

We already have seen the basic structure of the AST. We now write some code to generate it. We will generate only one Dec (i.e. the [Dec] in Q [Dec] will only have one element), corresponding to the one function we want to declare. The Dec will be a FunD (just like in the AST runQ showed us), with multiple Clauses, each representing one pattern (which itself corresponds to one String we were given at compile time).

One thing though — for some reason I don’t really understand, while runQ prints them, things in the GHC module (like GHC.Bool.True, GHC.Types.:) don’t really work in a generated AST. A token in TH is essentially a Name, which we can get using mkName :: String -> Name or by using the quote (') operator. So one way to get around the problem is to represent things like GHC.Bool.True as Names — this seem to work well in practice. The quote operator does not seem to work for symbols — we replace things like GHC.Bool.True with 'True and things like : with mkName ":". We also need to use mkName for the functions’ name, which needs to be a (surprise) Name.

Okay, phew! Time to see some code that actually works. With the little Haskell-foo I have, I wrote the following piece of code:

generateMatcher name strs =
  return [FunD (mkName name) (map thMagic strs ++ baseCase)]
  where
    thMagic str = Clause [transform str] (NormalB (ConE 'True)) []
    baseCase = [Clause [WildP] (NormalB (ConE 'False)) []]
    transform [] = ConP (mkName "[]") []
    transform ('?':rest) =
      let colon = mkName ":" in (InfixP WildP colon $ transform rest)
    transform (x:rest) =
      InfixP (LitP (CharL x)) (mkName ":") $ transform rest

Ten lines, as promised. I used return to lift the [Dec] into the Q monad. Other than, most of it is a direct translation of the input we get into something that looks like the output runQ dumped on me. The code is in my snippets repo, as usual. TH does not, as of now, allow you to declare an expression and splice it in the same file. You need to have, say, a FooTH.hs where you have all the functions for generating the AST and a Foo.hs where you actually use them.

TL;DR

This was a long and meandering post. In short, here are the two basic points I want to make:

• TH is awesome. It can save a lot of time, if used properly.
• Don’t beat yourself up trying to write ASTs from scratch, play around with runQ, steal and modify.

[1] http://www.haskell.org/ghc/docs/latest/html/users_guide/template-haskell.html

• Each object has a (header or otherwise) pointer-sized field which stores some information that can be differentiated from a pointer. On a system that is aligns words to two or four byte boundaries, we could set the LSB of non-pointer data stored in the field. We’ll call this field info.
• Pointers to objects always point to the beginning of some object. No pointing to a field stored somewhere in the middle.

The algorithm is extremely simple and elegant. All you have to do is this: every time you see a slot (a field, if you like) S point to an object O, change Os info field to point to slot S and set S to whatever value (pointer or non-pointer) info held before it was set to point to S. If you try this out with pen and paper (I’m too lazy to draw a diagram here), you’ll see that this simple action, when applied to every slot in the graph, transforms the predicate “Slots S₀, S₁ and S₂ point to object O” to “O‘s info slot contains a pointer to S₂, S₂ contains a pointer to S₁, S₁ contains a pointer to S₀ and S₀ contains the data O‘s info field originally held”. Since we can always distinguish a data word stored in info from a pointer, we can traverse this list and get a list of the slots. The slots can then be filled with new location of the object.

This is one of the main concepts behind Jonker’s compaction algorithm, except that it intelligently divides the compaction into two phases of updating forward pointers and updating backward pointers while moving objects.

I wrote a simple and tiny implementation of threading a graph, which you can find at https://github.com/sanjoy/Snippets/blob/master/Thread.cc. Note how the main threading algorithm only takes thirteen lines of C++.

The Deutsch-Schorr-Waite algorithm does not require adding any extra fields to the nodes. Adding fields to the node structure sort of spoils the fun — you could, for instance, have a pointer pointing to the parent of every node making stackless traversal a cup of tea. And you haven’t really saved any space! Thorelli’s approach, however, requires adding a integer to each node that can hold at least the maximum number of outgoing arcs a node can possibly have. But it can traverse graphs with more than two outgoing arcs per node. And you do save space here — if you have three outgoing arcs (maximum) per node, you could do with just a two bit integer. On x86, that’s the last two bits of a pointer.

Note that both the approaches are quite a bit more complicated than a vanilla DFS. Nevertheless, there are applications where such characteristics (of consuming only constant space) becomes important. One of the more visible ones is a GC. A GC has to traverse a (potentially) very large and complicated graph of objects, and it can’t use up too much memory (or call-stack space) when collecting — a time when memory is already a scarce resource.

I like implementing things, and while I did not implement the full algorithm proposed by Thorelli, I did implement one which traverses a tree in constant space. What more, it does not need the extra bits Thorelli’s algorithm requires.

The code is here (I believe in making code talk instead of giving long, winded descriptions): https://github.com/sanjoy/Snippets/blob/master/Traversal.cc.

The snippets repo is an idea that I recently got — I often code small things when I’m bored or want to try something out. Having a public “snippets” repo where I upload all that smelt good.

This is one of those posts I write to ensure I actually understand a concept. Read at your own peril. Some knowledge of Haskell is required.

The Problem

One Hello World problem that is sometimes used to demonstrate a programming language is generating the Fibonacci series. The n^th Fibonacci number is given as:

fib 0 = 1
fib 1 = 1
fib x = fib (x - 1) + fib (x - 2)

This, as it turns out, is one way to define the n^th Fibonacci number in Haskell. Save this code as Fib.hs, start the GHC REPL as ghci Fib.hs and you’re done — fib 5 evaluates to 8 and fib 7 evaluates to 21.

However, as cute this may be, it isn’t elegant enough. Fibonacci is essentially a series, and while mathematicians will tell you that a series is essentially a function (and that “is essentially” is a transitive relation) this definition does not, yet, sit quite well. Of course, you say, something like this can be done:

fibSeries = map f [0..]
            where
              f 0 = 1
              f 1 = 1
              f x = f (x - 1) + f (x - 2)

Not only is this approach a hack but is also quite slow. One nice, canonical, way to define fibSeries is this:

fibSeries = 1:1:zipWith (+) (tail fibSeries) fibSeries

Note the recursion here — the series of Fibonacci numbers remains the same if we take a list of two 1s, and append it with the elementwise sum of the list of Fibonacci numbers and the list of Fibonacci numbers less the first element. Let this sink in.

Enter the fixed point combinator.

There happens to be another, more elegant, way of expressing fibSeries, using fix, Haskell’s fixed point combinator. The above definition of fibSeries refers to itself in its definition. Let’s say you don’t want this, perhaps for pure intellectual pleasure (like here :P) or for deeper reasons — untyped lambda calculus, for instance, does not have named values, and so you cannot write an expression that refers to itself. In such cases, we use a fixed point combinator.

The first interesting thing about fix is its type: :t fix in ghci (fix is in Data.Function) will tell you its type is (a->a)->a. This should strike as counter-intuitive — how can a function possibly take a, say, Integer->Integer (let’s call this function foo) and return an Integer? It needs some value to apply foo to, right? The short answer is that fix calculates foo‘s fixed point. A slightly longer answer follows, which ends at TL;DR.

The fixed point of foo is the value v such that foo v equals v. It is fixed in the sense that no matter how many times we apply foo on the fixed point of foo, it remains fixed. One way to calculate the fixed point of foo is to apply it to ⊥ infinite number of times. This works because a type is a complete partial order and that foo is (Scott) continuous. In general the person defining foo needs to ensure this, but, thankfully, in Haskell, all functions you can possibly define are Scott Continuous. Relevant theory is here. Keeping this way of looking at fix in mind (infinite applications of foo on undefined), you could implement fix as:

fix x = applyInfinitely x undefined
  where
    applyInfinitely f x = f (applyInfinitely f x)

There are other ways to define fix, of course. In an untyped lambda calculus, you can define it as fix f = \x -> f (x x)) (\x -> f (x x) (this is the famed Y combinator). If you’re well-versed with types, you could implement the Y combinator in Haskell too; but then you’ll have to depend on recursion at the type level. I like to think of fix as something that encapsulates recursion, allowing you to write expressions that don’t have any explicit recursion, but are recursive nevertheless.

TL;DR

Coming back to the meaty aspects of fix, how do you write the function in whose fixed point is the value you want to compute? In this case we want fix to produce a [Integer]. This means the function we will write (foo) needs to have the type [Integer]->[Integer]. Which means it will take an [Integer] and return an [Integer]. But what [Integer] does it take? The same [Integer] it is supposed to return! As a first attempt, with this knowledge, you could write:

fibSeries = fix (\x->x)

I mean, since fix‘s argument (we’ll call it foo consistently) is somehow magically the same [Integer] foo is supposed to return, what could be more straightforward? However, something smells wrong. Both because of the word magically and the fact that this definition of fibSeries simply does not contain any information specific to the Fibonacci series (well, except the name fibSeries, but I think that is expecting too much of GHC :D). One thing I had not mentioned is this: when we say “fixed point” we really mean “least fixed point”. Deep in his or her heart, everyone who plays with types knows that a type is a poset with a bottom (⊥). The ordering in this poset is essentially information based — A > B ⇒ A has more information than B. So, in the poset of Integers, 1 and 2 are incomparable, since both of them contain an equal amount of information. And then you have ⊥, which contains the least information of all. What is the least value (in terms of the “least” defined above) that can be the fixed point of \x->x (the identity function)? ⊥, of course! Since (\x->x) ⊥ is ⊥ and no doubt, ⊥ contains the least information of all by definition!

A more intuitive way of looking at this is that when constructing foo, you need to make sure it adds some information. You need to embed some extra information into foo to ensure that, given the value you’re supposed to return, you also do some identity preserving operation on it, assuming that it is the same value you’re supposed to return. This is not as hard or tricky as it sounds. For instance, calculating fibSeries using fix is a direct extension to the self referencing definition of fibSeries:

fibSeries = fix (\x->1:1:zipWith (+) (tail x) x)

Another cute example is using fix to define a factorial function:

factorial = fix (\f x->if x == 0 then 1 else x * f (x - 1))

By the way, why won’t this

fibSeries = fix (\x->1:zipWith (+) (tail x) x)

work?

For instance, I could argue about how we all are automatons driven solely by the desire to increase the entropy of the universe. Not a very useful way to discuss why A’s marriage did not work out, is it? I find it more useful to look at human beings as a reflection of their line of existence through time and place. This way, I treat a person not as someone (or something) contained in the physical realms of his or her body; but as a context that spreads out in time and space. The coffee he’s drinking is changing his mood, why should it not be as much “him” as his tonsils? How about the kindergarten school she went too? Is that not as much “her” as her retina? How about the book she’s reading? This way of thinking about people is very rewarding (I personally think so) — it allows me to be more compassionate, understanding and patient. Once the object of your frustration is no longer a sharply defined physical entity, things start to diffuse and you begin thinking more clearly.

As a result of this context (spatial and temporal) which everyone carries around, we have certain goals, aspirations and biases. That is, what I think, makes us human.

I have had arguments with my peers on things like whether it is better to live comfortably without free speech and liberty or to live without material comfort surrounded by intellectual freedom. But such arguments are probably too restrictive — maybe the North Koreans are actually happy! Perhaps they [2] really do think that their dear leader is divine. Maybe is isn’t some mass cognitive dissonance after all? I find their condition desolate and pitiful because I am carrying around this huge bag full of my own context, which I shamelessly dump on them. What is it really, to think in someone else’s shoes? Can I possibly think like a unwanted child born to a prostitute in a Bombay slum? My personal rationality is biased, more so when applied to analyzing others.

It seems to me that everyone, on account of the biases in their rationality and the inherent context they carry, tend to distort their world in their own unique way, by reflecting themselves off a mirror that isn’t really perfect and by looking at others through tainted glass. But then how do you reason about the flaws in your rationality using your flawed rationality? Maybe this, the dents in our looking glasses, is the human experience. Perhaps without it the world would be a very boring place.

I still maintain that our existence, at the very base level, is purposeless and incidental. But I now have something shiny to look forward to — the human experience; something that can not be dissected, explained and thrown away.

Thanks to all those who disagreed, those who still do, chai and Albert Hofmann.

[1] http://www.edge.org/3rd_culture/eagleman09/eagleman09_index.html
[2] I’m talking about the majority here — some people do try to escape.

I think, it is connected to a previous track titled Mother. The movie (album) is about the construction and (later) deconstruction of a metaphorical wall. The wall exists at many different levels (for instance, as the divide between the elite and the starving masses, apparent in What shall we do now); the most basic being the protective wall built around Pink by his mother.

Mother has a line on how Pink’s mother would check all of his girlfriends for him and won’t let anyone dirty get in. Here, Pink wanting a dirty girl signals the beginning of the wall’s destruction.

Pink Floyd amazes me every single time.