Aaron Feng

Learning from io

Aaron Feng — Wed, 24 Sep 2008 23:09:00 -0400

io is a small, prototype based, dynamic programming language that is inspired by Smalltalk, Self, NewtonScript, Act1, LISP, and Lua. Need I say more? It has a very useful feature that any programmer can appreciate: the "?"

It's very common to want to check the existence of an object before accessing it.

if offer != nil
  offer.price
end

offer && offer.price

It gets even more tedious when you also need to traverse a couple objects deep.

offer && offer.price && offer.price.formatted_amount

Littering the "check" around the code can quickly cloud up the intention of the code. In io, you can do the following:

offer ?price
offer ?price ?formatted_amount

No more checking! However, I want to do that in ruby. An obvious solution is to open up the nil class and re-implement the method_missing to return nil. This is a very bad idea, since it applies to ALL objects in the system. It can hide serious errors within the application and make debugging very difficult. A better solution is to the following:

class Object
  def _?()
    self
  end
end

class NilClass
  def _?()
    SafeNil.new
  end
end

class SafeNil
  def method_missing(*args, &b)
    nil.send(*args, &b) rescue nil
  end
end

The above code is taken from this post The post didn't mention io, but I assumed it is inspired by it. In ruby you can't just use the "?" for your method name, therefore, _ is prepended before "?".Now you can do following without checking the parent object:

offer._?.price._?.formatted_amount

if offer or price is nil, nil is returned.

Software Development Meme

Aaron Feng — Sun, 31 Aug 2008 22:24:00 -0400

Apparently I was tagged by Steve Eichert one month ago and I just noticed now. Not only I have been hibernating from writing blog posts, but I also have not had time to read them.

How old were you when you first started programming?

Freshman in college.

How did you get started in programming?

I was always into computers growing up, so it was a natural choice.

What was your first language?

Pascal.

What was the first real program you wrote?

I worked on a Star Trek adventure game in my senior year in college. I don't remember too much about it except that there wasn't much guide lines around it. The goal was making something interesting and to have fun doing it.

What languages have you used since you started programming?

C/C++, C#, Java, Javascript, Lisp, Ruby

What was your first professional programming gig?

If professional means that I got paid for it... and if shell scripting is considered to be programming... Once upon a time, I worked as an AIX Unix Admin and wrote shell scripts to automate mundane, but critical, daily tasks.

If you knew then what you know now, would you have started programming?

Fo-sho.

If there is one thing you learned along the way that you would tell new developers, what would it be?

Focus on the basics.

What's the most fun you've ever had ... programming?

This is really hard for me because I enjoy programming in general. Of course, at times it can get tedious, but overall I find it fun to be able to create things. If I had to pick one I would say the side project I'm working on right now. I don't want to get into the details right now, but it's a rails app that consumes amazon's web service.

Who’s next?

Leslie Polzer

Data recovery part 1: Freeze the dead hard drive

Aaron Feng — Thu, 31 Jul 2008 08:30:00 -0400

harddrive"/>

I am sad to say that the hard drive in my Macbook died a few days ago. When I boot up the laptop all I see is a blinking folder with a question mark on it which means that it can't find necessary files to startup up the OS. I tried to run the Disk Utility from the OSX install CD, but the hard drive isn't even mounted. To make matters worse, the last backup I had was from 2 months ago.

Right before the hard drive crash I was just starting to gain some momentum on my side project. Now everything is gone, including my motivation.

I poked around Apple Discussions and found out a lot of people are having similar hard drive problems. Some people were able to retrieve their data by sending the hard drive out to a data recovery service. I called one and I realized I'm in the wrong business! The price ranges from $1500 to $2000 if the data can be recovered.

In disbelief, I went to the all knowing god, Google, for answers. I came across a couple sites that have claimed success on temporarily "fixing" a dead hard drive by putting the entire drive in the freezer for a few hours. Supposedly this will allow the hard drive to function for 10 to 30 minutes depending on the condition of the drive. Sounds pretty bogus to me, but desperate time calls for desperate measures. I have nothing to loose, so I decided to give it a go.

I sealed the hard drive in a couple zip lock bags and left it in the freezer for 3 hours then I stuck it back into my laptop. I boot up the Macbook with the frozen drive, hoping it would buy me enough time to backup a few items. Just a few seconds into the boot process, I see the blinking folder with the question mark again. I repeated the process a couple of times without any success.

Freezing the hard drive is only my first attempt on recovering the data. I purchased an identical hard drive from ebay and am hoping to repair it by swapping out parts. More to come in the next post. Before I go, I just want to say If you haven't been backing up your data recently, DO IT NOW!

Closure Fun

Aaron Feng — Mon, 30 Jun 2008 19:52:00 -0400

PHP has a string tokenizing function called strtok that has an interesting interface compared to many languages. What makes strtok function interesting is that creating the tokenizer and generating tokens utilize the same function. For example:

$tok = strtok("closure fun", "  ");

while ($tok !== false) {
    echo "$tok\n";
    $tok = strtok("  ");
}

The code above tokenizes the input string by a space, and outputs each token on a newline. What makes this function interesting is the ability to maintain state! I don't know what happens under the hood, but it appears to "remember" the input string after the tokenizer has been created. This behavior can be easily mimicked by using a closure variable. Below is an implementation in lisp:

(let ((rest nil))
  (defun strtok (string &optional (token nil token-supplied-p))
    (check-type string string)
    (when token-supplied-p (check-type token string))

    (when (and string token) (setf rest string))
    (let ((items nil)
          (output nil))
      (loop until (or (null rest)) do
           (setf items (cl-ppcre:split 
                        (funcall (lambda () (if token token string)))
                        rest 
                        :limit 2)) 
           (setf output (first items))
           (setf rest (second items))

           (when (not (string= output "")) 
             (return-from strtok output))))))

The "rest" variable outside of the function declaration is the closure variable. The "rest" is in fact invisible to the outside world, and it allows the function to maintain state!

Lisp ninja 2 - Refactoring

Aaron Feng — Sat, 31 May 2008 23:01:00 -0400

Last post I talked about creating an abstraction using Lisp macros to assist me with my unit tests. If you look at the code, there is an obvious flaw. get-result-for-test-case hard codes the target PHP function in it. It wouldn't be very nice to rewrite a new version of it every time I need to call a different PHP function.

In the original code from last post, the target PHP function was defined in string format. Since I'm working in Lisp I would prefer to define it in sexp format to gain the most flexibility. For example, calling the explode function in PHP would look like the following:

(explode " " "aaron feng")

Let's start the refactoring:

; helper function
(defun quote-string (input)
  (if (typep input 'string)
    (format nil "\"~a\"" input)
    input))

(defun get-function-signature (function-info)
  (let ((function (first function-info))
        (parameters (rest function-info))
        (signature "") 
        (delimiter ""))
    (setf signature (format nil "~a~a" function "("))

    (loop for parameter in parameters do
         (setf signature (format nil "~a~a~a" 
                                 signature
                                 delimiter 
                                 (quote-string parameter)))
         (setf delimiter ", "))

    (setf signature (format nil "~a~a" signature ")"))))

get-function-signature does all the dirty work by converting input function in sexp format to a string that we can eventually send to PHP. Let's incorporate this function back into get-result-for-test-case, so it can accept other functions.

(defun get-result-for-test-case (func-info)
  (with-output-to-string (str)
    (let ((func-string
           (concatenate 'string "print_r(" (get-function-signature func-info) ");")))
      (run-program *php-bin* (list
                              "-r"
                              func-string)
                   :output str))))

With these changes, it will make get-result-for-test-case much more generic. However, there is another problem, not all PHP functions return a string. If the function returns an array, the output will always be "Array". It would be nice if it could convert PHP array back into Lisp list, so it can be used for comparison in the tests. That is exactly what I'm going to do next. Notice that I replaced the "echo" with "print_r", so it will output human readable values for data structure such as array.

(defun parse-php-array (array)
  (let ((parts (split-sequence #\Newline array))
        (output))
    (dolist (part parts)
      (let ((value (get-array-value part)))
        (format t "~a" part)
        (when value (push value output))))
    (reverse output)))

Now if I wrap get-result-for-test-case with parse-php-array, it should convert the output into a Lisp list.

(parse-php-array (get-result-for-test-case `(explode " " "aaron feng")))

Of course, more work can be done to make the code more intelligent, such as, only try to parse array if the output is an array type. Currently the code can only handle Array and String as return type, but it can be extended further if desired.

Lisp ninja

Aaron Feng — Tue, 29 Apr 2008 22:27:00 -0400

It's not hard to get caught up on cranking out code when you are in the zone. All of the unit tests are passing one after another, and the implementation just flows out from your finger tips. There's no need to stop, step back and question the work because everything feels so right. Situations like this can really hinder your ability to unleash the power of your language. Especially if Lisp is your language of choice. After all, Lisp is the official programmable programming language.

This recently happened to me. I have been working on a side project (I'll talk about it in later post) that required me to implement string functions in Common Lisp that are similar, in spirit, to ones found in PHP. Since I'm a huge fan of TDD, I started with a failing test. However, before the failing test can be written, I need to confirm the actual behavior in PHP. During my the implementation cycle, I toggled back and forth between PHP and Lisp. This can get tedious over time, but I just kept chugging along.

This morning Kyle Burton showed me the light. He sent me a few pieces of code that remove the tediousness from my implementation cycle. I adopted the code to fit my environment and the testing framework. Without further adieu:

(defparameter *php-bin* "/opt/local/bin/php")

(when (not (probe-file *php-bin*))
  (error 
   "Error: %s was not found, please update *php-bin* to point to your php." 
   *php-bin*))

(defun get-result-for-test-case (instr 
                 &optional (width 75) 
                 (lbreak #\Newline) 
                 (cut nil))
  (with-output-to-string (str)
    (run-program *php-bin* (list 
                "-r" 
                (format nil "echo wordwrap(\"~a\",~a,\"~a\",~a);"
                    instr
                    width
                    lbreak
                    (if cut "true" "false")))
         :output str)))

(get-result-for-test-case "aaron feng" 3)

I was executing PHP code externally just to get the output, so I can use it in my unit tests. Why not ask PHP from Lisp!

The last line calls get-result-for-test-case function which calls the PHP wordwrap function directly and returns the result. Now this removed the need for me having to go outside my Lisp environment while I'm hacking. Why stop here? Why not have a macro that generates the test case using the result from PHP?

(defmacro create-test-case (test-name string &optional (width 75)
                (lbreak #\Newline) (cut nil))
  `(addtest ,test-name
       (let ((input ,string)
         (expected ,(get-result-for-test-case string width lbreak cut)))
     (ensure-same (wordwrap input ,width ,lbreak ,cut) expected))))

(create-test-case empty-string "   " 4)

Voila, instant test case. the last line shows how the test case can be generated on the fly and run. If you are a real ninja, you need to take one more step further.

(defmacro create-test-cases (&rest cases)
 `(prog2
      (deftestsuite wordwrap-suite () ())
      ,@(mapcar #'(lambda (case) (macroexpand-1 `(create-test-case
,@case))) cases)))

(create-test-cases
                (empty-string1       "   ")
                (empty-string2       "   " 4)
                (no-wrap             "foo")
                (wrap-one-word-at-1  "foo" 1))

create-test-cases creates a testing suite to host all the test cases then it generates test cases based on input. This takes WAY LESS typing than hand writing each test case. I no longer have to switch between two environments (PHP and Lisp) because it's all automatically done for me! Thanks Kyle!

Lisp has no syntax. Lisp has no parentheses. Lisp as no lists.

Aaron Feng — Sun, 27 Apr 2008 23:49:00 -0400

Lisp is often viewed as strange in syntax and parentheses centric language that only thing it cares about is processing lists. After all, the name is derived from LISt Processing (LISP). But it couldn't be more wrong!

Pascal Bourguignon has a great post on the lisp mailing explain why Lisp has no syntax. Lisp has no parentheses. Lisp as no lists. For the lazy readers, who don't want to click on the link, I'll give a simple break down of the Bourguignon's post.

Lisp has no syntax

Anyone with knowledge of how a compiler works would know that the job of a parser is to create a parse tree. The parser has knowledge of the syntax of the language so it can transform tokens from the source code into a tree structure. The reason Lisp doesn't have a concrete syntax is because the source code is in parse tree syntax. A parse tree can be represented in many formats.

Lisp has no parentheses

In lisp, a list is constructed by placing elements in the list between parentheses and leading the first parenthesis with a single quote. For example '(a b c). Internally lisp doesn't store or know anything about parentheses.

Lisp has no list

Lisp has no list type. List is an abstraction on top of the CONS cells. A CONS cell is equivalent to a node in a link list. It has two pointers; one points to data and other points to the next node or nil.

I've only covered each point superficially, but Bourguignon's post contains a lot more details.

Lisp newbie jump start

Aaron Feng — Mon, 07 Apr 2008 23:46:00 -0400

Many that are close to me have noticed my new obsession with a language that was invented in 1958: Lisp. I don't think there has been a day that goes by that I don't make some kind of reference to Lisp. The more I read about Lisp, the more mind blowing it is to me that most people don't use it. I understand Lisp may be an acquired taste, but there are many interesting concepts/features that can impact one's thinking even when they are not using Lisp.

Everyone complains about the parentheses. Please complain about something original. To tell you the truth, after a couple of weeks, you won't even see the parens anymore. You don't have to be a genius to do it, trust me, I'm definitely not one.

With that said, I would like to recommend three books that have helped me gain an understanding of Lisp. Best of all, they are all free! The only cost is your time, and desire to learn.

If you don't want to pull your hair out, I would suggest you read "On Lisp" last as it contains many advanced topics. It doesn't matter which order you read the other two books. They require no previous Lisp experience. The book by Touretzky is actually targeted for people with no programming experience at all, but I found it useful just to skim through real fast.

What are you still doing here? Click on the links and start reading!

Busy Apple

Aaron Feng — Sun, 30 Mar 2008 23:06:00 -0400

Yesterday was the grand opening of the second Apple store in my area. I was out and about, so I decided to stop by the store around the opening time: 10 am. I have never been to a grand opening of an Apple store before, and to my surprise, there were tons of people waiting in line just to get into the store.

Even though Apple was giving out free t-shirts to the first 1000 customers, there was still an impressive amount of people there.

barf and slurp with paredit

Aaron Feng — Sun, 23 Mar 2008 20:58:00 -0400

If you are not barfing and slurping with paredit while you are editing your Lisp code in Emacs, you are missing out. You need to read on.

One of the biggest complaints for beginner Lispers (like myself) is the overwhelming parentheses. After working with Lisp code for a couple of weeks, the parens do disappear. However, you still have to match up the parens even if you don't see them any more. This is where paredit comes in. Paredit will manage all the parens for you, so you never have deal with dangling parens again. It feels annoying at first because it will not allow you to delete a closing paren without removing the opening one. Just like anything else, if you can get over that, it can be quiet useful.

Two of my favorite features are barf and slurp. They are best explained with examples.

; starting with the following sexp

(x (y) (z))

; barf forward...

(x (y)) (z)

; barf forward...

(x) (y) (z)

; slurp forward...

(x (y)) (z)

; slurp forward...

(x (y) (z))

; barf backward...

x ((y) (z))

; barf backward...

x (y) ((z))

; slurp backward...

x ((y) (z))

; slurp backward...

(x (y) (z))

You get the point. There are many more features to paredit besides barf and slurp. If you are interested in learning barfing, slurping and other delicious paredit features, check out this link.