Why I love Common Lisp and hate Java, part II – code examples

This is a sequel to my previous post where I urged those who gave up on programming — probably because of the spoon-fed association with Java and stress — to give coding another chance with a whole “new” (read: different) approach: Common Lisp. The purpose of this sequel is to address the open-minded skeptic, unconvinced yet unafraid of paradigm-shifting change. Common Lisp is not just another language, it is a different way of coding.

While I tried to make a point that the REPL completely alters the experience of coding — which can only be experienced and not by reading a blog post — this time I will try to showcase Common Lisp’s powerful meta-programming through some example code.

Writing programs to write programs is mind-boggling if you come from the imperative world of Java. Simply because it is not possible in Java, therefore not taught, hence not even considered as a powerful way of abstraction and code reduction. We write methods and functions to abstract away reoccurring computational patterns. Why not write functions that take the abstraction level even higher and abstract away coding patterns?

Suppose we write a method in Java that returns the maximum value given an array:

public static int getMaxValue(int[] numbers) {
	int answer = numbers[0];
	for (int i = 1;i < numbers.length; i++){
		if (numbers[i] > answer) answer = numbers[i];
	}
	return answer;
}

And it’s equivalent in Common Lisp (ugly Lisp code beware: I’ve tried real hard to keep it as imperative and iterative as possible for our fellow Java coders):

(defun get-max-value (list)
  (let ((ans (first list)))
    (do ((i 1 (1+ i)))
        ((>= i (length list)) ans)
      (when (> (nth i list) ans)
        (setf ans (nth i list))))))

Now what do we do when we want to write a function that will return the minimum value? Simple, just copy-and-paste the code, rename the method name and change the predicate:

public static int getMinValue(int[] numbers) {
	int answer = numbers[0];
	for (int i = 1;i < numbers.length; i++){
		if (numbers[i] < answer) answer = numbers[i];
	}
	return answer;
}

That’s all there is to it, right? Now this is when most of us would get up for another cup of Java, while deliberately unintentionally keeping their screen on and filled with lines of code — a sense of false but incentivized productivity.

Lispers get itchy. Good coding practice is all about re-using code and minimizing code duplication, so whenever our laziness brings us to copy-paste, our Lisp intuition tells us it is a bad short-term solution. Using copy-paste means that there is going to be a large chunk of code that will be duplicated, which needs, should and most importantly CAN be abstracted away in Common Lisp. As a matter of fact, there are two ways to do this: write a macro, or write a function that will accept the predicate as a parameter.

Let’s start with the latter, since it’s easier to grasp. Common Lisp allows methods (Java jargon) to accept other methods as parameters. It is even possible to return methods as a result of a method call. Let’s see how we can apply this to writing the above in Common Lisp:

(defun get-from-list(list pred)
  (let ((ans (first list)))
    (do ((i 1 (1+ i)))
        ((>= i (length list)) ans)
      (when (funcall pred (nth i list) ans)
        (setf ans (nth i list))))))

We just add another parameter called pred, and changed the greater-than sign to a function call to pred. Now we can define both get-max and get-min using the above:

(defun get-max(list)
  (get-from-list list #'>))

(defun get-min(list)
  (get-from-list list #'<))

Isn’t that beautiful? Let’s take a second to soak up the elegance.

Meanwhile, let’s do that again, but this time with a simple macro. Note that it is generally bad practice to use macros where functions suffice. The following is just an example to warm up your meta-minds, before I show you another example where macros prove truly invaluable.

(defmacro get-from-list(list pred)
  `(let ((ans (first ,list)))
     (do ((i 1 (1+ i)))
         ((>= i (length ,list)) ans)
       (when (,pred (nth i ,list) ans)
         (setf ans (nth i ,list))))))

The easiest way to get your head around macros is to consider it as boiler-plate code, where you plug in your pieces of code by using the parameters. Whatever you provide to the first argument in the above, will be plugged into the code (at compile time) wherever you see ,list. The same goes for pred, so we can now define get-max and get-min again with:

(defun get-max(list)
  (get-from-list list >))

(defun get-min(list)
  (get-from-list list <))

Do I see a smile, Mr. Java?

Notice the subtle difference; since we use macros, unlike the previous example where we provided a function as an argument, we are just passing along pieces of code. The #’ notation depicts a function, so we drop that, just like we don’t need to funcall on the predicate. The get-max definition will compile behind the screens into identical code as the get-max-value definition a few page scrolls above.

The best part is if you need to adjust the function, e.g. to ignore null values in an Integer array. That’s when Java gets real messy. You don’t do that. The whole point of declaring variables is so that you can change it in one place. Why, then, do you change functions in multiple places and not complain?

Actually, I have one more example to share with you that got me sitting up straight in euphoria, when I was writing some test suites for Open-VRP, but since there is enough to digest for today — a paradigm shift is hard to come by — let’s leave that for another post.

Realizing and understanding that you can use a macros to code, feels a little like obtaining your driver’s license. Not only are there now many more ways to get there, but places that were inaccessible before suddenly become destinations.

Continue to Part III – macros

---

I am sure there are plenty of great Lispers out there who have done some strong meta-programming. Feel free to send me a link to your favorite meta-hack example and I’ll add it below.

• Edi Weitz’ talk on The Power of Lisp Macros
• Practical Common Lisp: Chapter 8 on macros
• Onlisp: Chapters 7 through 17
• Reddit: What are some fun or useful macros?