Sometime ago, after reading some LWN articles (highly recomment an LWN subscription if you are interested in Linux kernel). But I found the going tough. There are lots of scattered information. Even though the software is all Free, it was impossible to comprehend why certain things were done the way it was done. It not only required reading articles (paying close attention to the date on which it was written), it also required digging into the past on how things looked before and how it changed. Most of the time, a long list of APIs are given which can only be comprehended by those working on it for a long time. It was very frustrating. I even wondered how anyone new can contribute to such projects after a few years when the current crop of experts have all lost interest in these projects or have passed away.

If you find yourself also in the same position as me, here are some pointers to some gems I found in my journey that does give a big picture of the GNU/Linux graphics/display sub-system. No, I am not competent enough to explain it myself yet, I would rather leave that to masters who have actually worked on it.

To get an overview of the various terminologies involved (DRM, DRI2, KMS, EGL, X, XRender, Wayland, pixman, cairo and other alphabet soup) start reading this overview article ”The Linux Graphics Stack”. Another great overview is this little PDF file which has short explanations of all the key pieces of the graphics stack from the hardware bits to the application. Once you read it, head straight to Wayland Architecture page which explains how X draws the screen and how Wayland is simplifying the picture. Pay particular attention to the journey of an event and its effect on the screen.

Now you are reading to watch this great LCA 2013 video on X and Wayland by X/Wayland hacker, Daniel Stone and look at the corresponding slides.

Another great video is the Episode 6 of “The luminosity of Free Software”, a Google Hangout series by KDE uberhacker Aaron Seigo. Another great article written in 2005 about the state of GNU/Linux graphics by Jon Smirl.

And then we have the great LWN, which is an essential reference to every linux kernel programmer. There is a bunch of links to the relevant LWN articles and other discussions and slides on thie Linaro Memory Management page.

Graphics

Again I am a journeyman into Graphics, trying to make sense of various terminologies. There are two pages, that I found helpful.

• Learning Modern 3D Graphics Programming
• An Intro to Modern OpenGL

Hopefully, these links will give a good “big picture” view of the low level parts of rendering/video/graphics inside a modern GNU/Linux desktop. Also remember to watch the date on which this post was written (because The Internet does not forget anything and you, the reader, may be reading this page many months/years after the day this post was written). The display side of things being the most user visible and sensitive thing, is ever changing. The picture may look entirely different after a few years.

Last year, when the online AI Class was announced by Sebastian Thrun and Peter Norvig, I was thrilled and immediately signed up. Soon two other courses were offered. At work, I do low level software and have not formally studied AI or Databases or Machine Learning, not did I really see a need, in immediate future, to apply them in my job. Neverthless, I was thrilled at the possibility to hear and work with Stanford professors through these courses and enrolled for the AI course.

The AI class started and I think I could keep up my motivation level for the first 3 or 4 units. There were others distractions like family and work. I had to do a bit to extra work to learn some background mathematics and also read up the text to keep up with the lectures. Somehow, at that point of time, it all couldn’t fit together in my scheme of things, so I decided to discontinue. When I think back, I think I could have completed the course with a bit of extra effort, which I was not really putting at that point of time, instead I came up with some excuses! One of my cynical friends had predicted that I and some others at work who enrolled with me would all discontinue the course and I was sad that he was right.

Then the creation of Coursera and Udacity were announced. When I saw the announcement for the Design and analysis of Algorithms - 1 course from Stanford, I was extremely thrilled. I had always wanted to learn about analysis of algorithms but have never taken a formal course. I enrolled for the course and started working on the lectures. Tim Roughgarden, who was the lecturer for the course was going at a bit fast rate than what I could keep up. But somehow I caught up with lectures by working on them late nights and early mornings. I took notes as I went along. Taking notes meant, I had to watch the same lecture two or three times in some cases. It quickly blew up the time required to complete one week worth of lectures and sometime spilled over to the next week. But for me, it was liking playing a game. The problem sets and programming assignments were staggered by a week and so I could submit them on time. I was looking forward to the lectures and what new stuff Tim is going to throw at us, students. I did not find much time to participate in the forums. The programming assignments were mostly easy and was something I was really looking forward to. I used Racket for my programs and turned out that some others taking the course were also using Racket. It was a joy to program in Racket through out the course. During the last week of the course, I was with my parents and didn’t have a working Internet connection. After struggling with the phone company and wasting a lot of time on it, I decided to download the vides from elsewhere and work offline. In the end, I used my phone to connect to the Internet using GPRS and use my laptop via tethering to submit answer to the problem set and programming assignments. Overall, I think I did the tests very well.

Here are somethings I liked/disliked about the course:

• Teacher is the most important element in a class. If teacher is uninteresting, everything else is. No amount of technology can save the situation. Tim is a great teacher. He talks a bit fast but after a while I started loving his style of talking and teaching. Some other classes (don’t want to point fingers at any specific course) didn’t have as good a teacher as Tim.
• Free style writing on White/Black board instead of powerpoint was one of the highlights of the course. I think it was crucial for the success of the course. Many other courses which I signed up at Coursera were using powerpoints and the teachers (some of the greatest names in CS) were reading out from the powerpoint slides. I couldn’t sustain interest in such courses, how much ever great those teachers are. The way Tim taught the class is a role model and brought back memories of some of the best classes I had taken in real classroom years ago when I was a fulltime student.
• Timing and difficulty level of the exercises within the lecture is another extremely important element.
• A good teacher is far far better than self-learning from a book. I learnt tons of new things in these 5 weeks than I would have ever learnt in 5 weeks of reading.
• The importance of taking notes cannot be overstated. This was the single best decision I ever took. I carried the notebooks around along with my laptop and used it whenever I got free time (sometime, even at work, when I am waiting for compilation to finish or in the evenings). The notes were handy while doing problem sets and programming assignments for a quick revisit to some particular lecture or to look up specific algorithm etc.
• I didn’t use any text book though Tim recommended a few. I have CLR with me, but surprisingly I didn’t use it much while doing the course.
• If I have seen one single use of Technology in recent times that positively affects the human beings, then that is this new experiment of online teaching.

Overall, it was a great experience with this course and I would like to thank Tim and Coursera for offering this great course online. I am looking forward to the part 2 of this course.

I also signed up for some of the new courses offered at Udacity. One of them that I am really excited about is the Web design course by Steve Huffman. I really like the style of presentation at Udacity. It is direct. It is short. The listener is tested at the end of (almost) every video. That makes it extremely interesting. Just like playing a video game!

I like new gadgets and have been tempted many times to acquire some of them (like new Android phones and tablets). Usually these gadgets have a short life though (until it becomes obsolete, but still useful) and then newer gadgets come along. One can go on spending money and chasing these gadgets.

These days, I do a bit more analysis. I really think hard if I really need those gadgets and whether I can live without one. More things in one’s life definitely means less available time for doing other things (like spending time with family or reading books) and certainly more pain maintaining them.

Moreover, most of these gadgets do not respect the user’s freedom. When you buy a stock Android phone, chances are that the bootloader of that phone is locked. What this means is that only binaries of the bootloader signed by the manufacturer can be installed. This is true of most (all?) phones available in the market currently. Clever people have deviced ways to keep the bootloader intact and still load alternate OS images (like the excellent CyanogenMod firmware for Android phones).

When one runs these modern gadgets, the Applications (or apps, as they are called these days) are tied to the users account. The Application distributor (like Google or Amazon) can remotely kill any of those application or the phone itself. This kind of application distribution is very different from the way a desktop computer application is distributed.

These kinds of scenarios are coming to the good old personal computing as well. The UEFI comes with similar restrictions (I have to admit that I haven’t read in-depth about UEFI itself).

The good folks at the FSF have been doing a lot of work on Software Freedom and educating the users on these issues (in addition to supporting a number of Free Software projects and defending the rights of the copyright holders as well). They need to pay the staff, host the machines and support various campaigns (print documents, flyers etc). All these needs money. Projects like Android are successful because they are standing on the shoulders of the great work done for the past few years on various Free Software projects (eventhough Android strives hard to avoid GPL for the userspace projects).

Please consider donating some money to the FSF. I have been a proud associate member of the FSF for many years now. Contributing money is the easiest thing one can do to help the cause. A better way would be to work on Free Software projects itself.

If you are thinking of buying a gadget, think carefully if you really need one and if so, choose one which respects your freedom and don’t become a slave of the manufacturer. Also please think of donating 10% of the cost you plan to spend to organisations like the FSF.

cKanren is a wonderful system created by Claire Alvis and the group at IU for relational programming. This paper describes cKanren. cKanren builds on another wonderful system called miniKanren created by William Byrd and Prof. Dan Friedman of IU.

Off late, I started reading “The Little Schemer” series and started reading the awesome ”The Reasoned Schemer”, also by the same team that wrote miniKanren. cKanren is written in R6RS scheme and is developed on Chez, evidently. Since I wanted to use Racket and DrRacket environment, I started looking at changes to be done to make it run on Racket. What follows below are the instructions to setup DrRacket for cKanren programming. I am using Racket version 5.2. If you are using other version, I recommend upgrading to v5.2 or above.

• Download my fork of cKanren

1

$ git clone git://github.com/vu3rdd/cKanren.git

• Switch to the ‘racketification branch’

1
2

$ cd cKanren
$ git checkout -b racketification origin/racketification

• Now, make cKanren module visible in the Racket ‘collections’. Note that ‘raco link’ works only on Racket versions 5.2 or above. (I will update this page when I learn about a solution which work with lower versions)

1

$ raco link .

• Now, fireup DrRacket. In the definitions window, use the following as the language.

1

#lang cKanren

• Hack away in cKanren!

I have been using an HTC Desire for one year now. This is also my first “smart” phone. I had been using cheap “voice-only” phones before. It took me a while to get accoustomed to the larger form factor of the phone. As a user, I liked the experience so far. Within a week of buying the phone, I “rooted” the phone and installed CyanogenMod, a popular after-market firmware built from AOSP. Running Free Software on my phone is an important criterion for me and that was the reason I chose Android (without knowing all the other factors like the manufacturer’s support for altering stock firmware, non-free graphics and other components required to run Android). Turned out that HTC has a very bad track record when it comes to GPL compliance and timely release of linux kernel sources. Desire is very similar to Nexus One. But a lot of non-free binary blobs are required to run Android. A lot of hardware abstraction layer libraries are non-free and needs to be pulled from the device.

Another annoyance is the fact that the phone becomes sluggish after about 300 hours of uptime. The screen goes blank or unresponsive after that. It becomes even more annoying when alarm rings and the screen is blank at 5.30AM, so that one cannot stop the alarm. The same is true when a call comes and the ringer rings but the screen is blank. I haven’t looked at logcat output when such things happen.

There are very few apps that are also Free Software. But one does not need many apps anyway. What I have seen from my own use is that I only need 3 or 4 applications. Maps, email, browser, weather, twitter. Perhaps that’s it. I may use an app here or an app there for some exotic use, but not on a daily basis. Not even Youtube app. But that’s just me. YMMV.

The battery usage is quite ok. I get to charge my phone in the evening when I get back home from work and before going to bed. I charge my phone perhaps daily or once in two days.

When I am on travel, I use GPRS extensively (surprisingly, location finding without GPS works amazingly well). I rarely switch on the GPS because it sucks power a lot.

The default partitioning of the internal flash is such that one gets “low memory” the moment one installs some bigger apps like the firefox. This can be changed.

I am very disappointed that Android can be programmed only in Java (yes, I have looked at Android Scripting project and have used the NDK but that’s not quite what I want). It would have been nice if any general purpose programming language and runtime could be used to write programs for Android. But unfortunately that is not the case.

I also don’t like the fact that AOSP is a not-truely-open Free Software project. Again, for those people confused about Open Source vs Free Software (and think that they are one and the same), here is a perfect example of an Open Source project which is not truely Free Software. Android was designed from ground up, not to be truely Free Software because only then the manufacturers can escape the legal hastles associated with Free Software. This is very unfortunate. They piggyback on the Linux kernel’s successful device drivers to easily support hardware and have purposefully used the Apache license for the rest of the software (with some exceptions like dbus, bluetooth etc). The software components are also not plug and play. They are highly integrated and cannot be easily replaced with other more featureful software existing in the Free Software world for a long time. This is extremely unfortunate because traditional Unix userspace philosophy is exactly opposite.

I had high hopes for Meego but looks like it is on the downside. I don’t really have much hope for B2G effort by Mozilla. They are building on top of Android HAL which is non-free even for the Nexus phones.

My next phone will be a 4” phone with similar feature set. But I don’t want blated software to push hardware limits. To run most applications, a dual core CPU is not needed. We can do a lot with a single core and a nicely designed runtime. I would not buy those big screen phones because I use voice a lot, not just data. It is extremely inconvinient to carry those large phones in the pocket.

I am very tempted to give Nokia N9 a try, but not anytime soon. I hope it will be cheap enough to try. I don’t really feel comfortable spending another Rs.25,000 just on a phone. I would rather spend that money on books.

Overall, I do not recommend HTC. And for those who do not care much about Free Software, Windows phone may be a much superior choice when it comes to usability.

2011 had been an extremely interesting year. I feel very happy to have made good progress on my Programming Language Theory learning. I am also qute happy with my SICP challenge project, which was my only noteworthy side project. I am somewhere in the initial portions of chapter 4 right now and it had been worth every minute I spent on it.

I also started reading many books connected with SICP and Programming Language theory, like TaPL and EoPL. Discovering the work of Dan Friedman was an eye opener and I hope to spend many many hours in the next few years learning from his books. I also read “The Little Schemer” and am well into “The Seasoned Schemer” and on to “The Reasoned Schemer” as soon as I am done. I will happily recommend these great books for anyone starting with Scheme.

Richard Stallman’s [post][] about Steve Jobs seem to have attracted a lot of bad press and some really thoughtful comments from Dave Winer and Eric Raymond.

The World in general likes Managers more than Engineers because Managers are the front face of the increasingly commercialized world. We associate people with where they work and not for the actual work we have done.

While I have no doubt that Steve Jobs contributed a lot in terms of user experience of the Apple products, I believe, the products he helped create (yes, let us not forget that there are people apart from Steve who worked on these products) were completely closed, literally with non-standard screws.

I am part of a generation who grew up in the analog world. Even among my peers, I am one of the late entrants to the computing world. There was a time when my only aim in life was to do ham radio hacking all the time. My interests have shifted to other things, but the knowledge I gained from electronics hacking was immense. One big contribution of Microsoft to the world is the cheap computers, though they never manufactured them themselves. This gave us computers which can be opened and tinkered. The amount of tinkering one can do with a modern computer is quite less because most of the functionality is sealed in big integrated circuits (Yes, OO thinking hit those electrical engineers much before it hit software people and the electronics folks do it really well. They actually reuse components, unlike we folks who have obfuscated code in the name of reuse). But still the fact that one can open one’s own computer and get a feel for the overall machine, change components etc is big deal.

Imagine today’s kids who grow up with Apple ipads. All they know is pointing fingers on the application widgets on the screens. They can’t really look under the hood. Even if they can (like in the case of Android phones), the system does not encourage them.

This is the case with even Free Software systems which mimicked Apple in the name of usability like the GNOME/KDE/Unity desktops. Most new users of these Free operating systems get access to these shiny and polished desktops. Back in the olden days, one had to do a lot of fiddling with X11 configuration files etc to get a graphical desktop and each of those fiddling with configuration files had been a great learning experience. Even a simple act like compiling a custom linux kernel for one’s own machine is a great learning experience because one needs to figure out what type of hardware one has, with various tools like `lspci’, poking of the BIOS configurations, reading motherboard manuals etc. Newcommers to computing, is going to be missing this experience because things have ‘improved’.

Modern devices based on Apple iOS and Android give too much power to the manufacturers though you ‘own’ your devices. It is not ‘your’ devices anymore. Google can (and recently did) wipe the entire phone including OS and applications from your phone. One can argue for academic sake that this can be defeated by not going online. That’s impractical and plain stupid. Amazon has wiped kindle ebooks that users legetimately purchased from their devices.

So, back to the title of this post. We take Free Software for granted these days, thanks to the work of Stallman and millions of others who contributed code, documentation and support on the mailing lists. You, the user should have more control over your data and devices than a handful of corporations in the world. This is true, not just for personal devices, but everything including your home router, your TV etc. In some sense, the dumber they are, the better. So, a plain old TV with just a screen is better than one with a lot of applications on it because internet connected TVs can spy on your TV viewing habbits and thus intrude into your privacy. Steve Jobs and his company has done a lot of damage to this world by making people love closed products. They do this so that they can extract money (in the form of applications and services) from the users every now and then, even after the product (or the platform) is sold. The users who are oblivious of these malicious designs get bought over. Sure, the user experience is enticing and one can get their work done with these devices. But they have the above harmful side effects which linger around for a longer time than we really think it will.

Guy Steele once said that ”A closure is an object that supports exactly one method: apply.”

When I read it a few days ago, I could not get much meaning out of it. While reading the SICP chapter 3, section 3.1.1, a bulb lit in my brain and I finally understood (atleast I think so) what he meant. I dug into other literature on the subject and found some more interesting stuff. Read on.

Let us consider the same example discussed by Abelson and Sussman in section 3.1.1, namely the withdrawal of money from a Bank account. One natural way of representing an account is to have an account object which has a way to represent the current balance. The following code reproduces it verbatim from SICP.

(define (make-account balance)
  (define (withdraw amount)
    (if (>= balance amount)
        (begin (set! balance (- balance amount))
               balance)
        "Insufficient funds"))
  (define (deposit amount)
    (set! balance (+ balance amount))
    balance)
  (define (dispatch m)
    (cond ((eq? m 'withdraw) withdraw)
          ((eq? m 'deposit) deposit)
          (else (error "Unknown request -- MAKE-ACCOUNT"
                       m))))
  dispatch)

Let us analyze what is happening in the above code. The make-account procedure creates an “account” object, so to speak, which is initialized with the balance, as follows:

> (define acc (make-account 100))
> ((acc 'withdraw) 50)
50
> ((acc 'withdraw) 60)
"Insufficient funds"
> ((acc 'deposit) 40)
90
> ((acc 'withdraw) 60)
30

A call to make-account with an initial balance value creates a closure with the variable balance together with the internal routines: withdraw, deposit and dispatch. The value returned by make-account is the procedure dispatch. To call a particular method of the object, we pass it as a message to the closure. The returned procedure is then called with the arguments. This is rather the message passing style of object orientation. Now, how does this relate to the comment made by Guy Steele that “closure is nothing but an object with a single method - apply” ?

The above code can be re-written as follows:

(define (make-account balance)
  (define (withdraw amount)
    (if (>= balance amount)
        (begin (set! balance (- balance amount))
               balance)
        "Insufficient funds"))
  (define (deposit amount)
    (set! balance (+ balance amount))
    balance)
  (define (dispatch m . args)
    (case m
      ((withdraw) (apply withdraw args))
      ((deposit) (apply deposit args))
      (else (error "Unknown request -- MAKE-ACCOUNT" m))))
  dispatch)

All we have done is to use the case special form and use apply. The interactions with this new procedure is shown below.

> (define acc (make-account 100))
> (acc 'withdraw 20)
80
> (acc 'deposit 120)
200
> (acc 'deposit 120)
320
> (acc 'withdraw 40)
280

As we can see, this is a neat and easy way to create objects and explains Guy Steele’s statement regarding closures vs objects. In another blog post, we will see how to implement inheritance and other OO concepts. As you can see, Scheme is really cool and is an excellent platform for language experimentations and prototyping of ideas.

I have been silent in the blogosphere for the past few months. Life continues to be very busy. The SICP study group is progressing well. I am having a lot of fun interacting with Tom, Pradip, Martin and others. I am close to finishing chapter 2. Almost all the exercises have been completed and tons of things learnt. I wonder how some people find time to do the problems and blog about them.

I also switched to Scheme from Clojure as my language for doing SICP exersizes for many reasons. One important reason is the fact that the purpose of the whole thing is to do SICP and general principles of Computation. I find Scheme to be an excellent vehicle for that purpose. Thinking back, I think it was emacs + slime which was holding me back from trying other alternatives. :-)

And then it happened. I bought ”The Little Schemer” by Dan Friedman and Matthias Felliesen and simply fell in love with it. In my opinion, this little book is a much more important book in computing than the mighty Knuth and K&R. True, they have their place. But this book conveys some of the most important principles in computation in a simple Q&A style. I had a smooth sail through it until I hit the chapter on Y Combinator (aptly titled “… and again, and again, and again .. “) which I had to read about 4 times and experiment on the repl to finally get it. Reading this book also motivated me to take a serious look at Scheme. I managed to grok some of the fine papers written by Dybvig, Felliesen and the other fine and friendly folks at the PLT. The PLT community and the mailing lists are one of the finest and helpful group of folks I have seen.

I am currently looking at Guile, the FSF’s own Scheme implementation. There are many factors which makes guile interesting. Guile is small, but at the same time good enough to be very useful to write large systems. It has a good C FFI and has a good module system, something I haven’t seen in the other Scheme implementation and is the closest thing to Common Lisp packages, in my opinion. It has a nice VM and a compiler, which is evolving. I hope I can learn a lot more by working with Guile than any other Scheme. Guile is actively being developed by Andy Wingo and others who can also be interacted with at the #guile irc channel, which is great. I use Emacs and geiser to interact with Guile.

Clojure was fun. I will return back to it when I have a need. I almost finished writing a blog engine with it and had a lot of fun writing it. But for now, Scheme definitely serves my needs for learning programming language fundamentals.

At this point, some people in the Clojure community are busy trying to get all the attention they can (and also sell some books, more in the works, so we will see a proliferation of such posts for the next many months) by posting every blog post they find on clojure to HN, Reddit and also repost the HN url back to twitter! The result of all these is that, a lot of people think Clojure is the first Lisp in this planet! I mean.. grow up, people! I am sure, they will settle down. Can’t resist posting this XKCD strip. But overall, over exposure of Clojure is good for all the Lisps.

I have a bunch of books waiting to be read or partially read:

• On Lisp (almost finished it, but planning to read again).
• The Lambda papers by Steele and Sussman.
• To Mock a mockingbird.
• PLAI (Shriram Krishnamurthi)
• EOPL
• PAIP
• The Joy of Clojure.
• …

Not sure whether a lifetime is enough to read and understand them all and also make something useful for myself and others to use.

I now have a very nicely working swank-clojure, completely configurable by hand and no ELPA magic. And this plays very well with the upstream slime as well as swank-clojure, albeit some small changes in the emacs lisp of the swank side..

The problem

Upstream swank-clojure supports only ELPA and those who want to configure swank manually are on their own. I, for one, do not like those “conventions over configurations” stuff, atleast for my programming environment. Heck, that’s why I use emacs in the first place.

In the past, I was using an older version of swank-clojure which fully supported manual configuration. I then switched to a newer version of swank-clojure but with a totally different emacs lisp code to make configuration for easy.

Also, I use the clojure and clojure-contrib from the debian packages, which installs into /usr/share/java. The same directory has all the other java jars as well. But upstream swank-clojure supported somewhat different directory structure. If invoked on a project, it picks up dependencies from a subdirectory called “lib” (configurable). lein puts all the dependencies (including clojure * .jar) into that directory. It built up a new classpath from these (assuming that the project is self-contained, including dependencies).

This unfortunately does not work in my case. I almost never use a build tool while fooling around doing random with slime. For example, to use Slime with my SICP exercises (I have moved on to use Scheme) where I do not have a build mechanism put in, it becomes difficult. Running tests for a namespace from slime is another reason why having the project namespace in the classpath is a very useful thing. For many simple projects that I do, all I need is clojure and clojure-contrib which is already in my classpath. But this made things difficult as adding the project being worked on into the classpath was messy. Becausee of the above setup, swank-clojure-project was unsable for me..

I also don’t like multiple copies of jars lying around. It is not the question of wasting disk space, which is very cheap anyway. But it is just a matter of taste and cleanliness. Multiple jars on each project directory is a convenience, but it is plain ugly.

Today I decided to clean up the whole mess. The end result is a much cleaner swank/slime.

Solution

Turned out the solution was very simple. When swank is started on a project, instead of changing swank-clojure-classpath, I build up another list using a variable called swank-clojure-extra-classpaths. This is then appended to the swank-clojure-classpath before starting up the JVM.

I also disabled the code which checks the presence of clojure * .jar files in some predefined location when swank starts up. This can always be called manually, if one wants to.

Code

For those wanting to follow similar approach, here is my github fork of swank-clojure with instructions on setting it up. The emacs repl (via ielm) was invaluable for debugging.