Wacky Crazy Weblog

Insertion Sort

2006-07-17T12:30:00.000-07:00

Its been a while since I posted any Lisp content and I have not been in touch for long. For anyone trying to get in touch, I still don't have access to my Yahoo account.

Well, I was trying a simple insertion sort algorithm directly from a book.


(defun insertion-sort (A)
  (do ((j 1 (+ j 1)))
      ((>= j (length A)) 'done)
    (let ((key (aref A j))
          (i (- j 1)))
      (while (and (>= i 0) (> (aref A i) key))
        (progn
          (setf (aref A (+ i 1)) (aref A i))
          (setf i (- i 1))
          (setf (aref A (+ i 1)) key)
          (print x))))))

The while is just a macro copied out of ANSI Common Lisp and very basic (no gensyms etc). Just for reference, it is


(defmacro while (test &rest body)
  `(do ()
    ((not ,test))
    ,@body))

Executing it as follows (Followed the algo by the book).


CL-USER> x
#(5 2 4 6 1 3)
CL-USER> (insertion-sort x)

#(2 5 4 6 1 3)
#(2 4 5 6 1 3)
#(2 4 5 1 6 3)
#(2 4 1 5 6 3)
#(2 1 4 5 6 3)
#(1 2 4 5 6 3)
#(1 2 4 5 3 6)
#(1 2 4 3 5 6)
#(1 2 3 4 5 6)
DONE
CL-USER> x
#(1 2 3 4 5 6)

Its amazing, how much one forgets in a few months/years.

Rocket & Ricotta Special Rolls

2006-06-03T13:51:00.000-07:00

Well, I am back after a long sojourn. Its been more than a year since I blogged. Sorry to people who have been reading and following along.

We made an interesting looking meal today and it looked fairly ok and tasted quite good. It appears to be pretty healthy too.

I will list all the ingredients here and you folks can try to figure out what went into it. Its not as simple as it looks as it does comprise of a lot of leftovers which were not that easy to make. So if someone wants the recipe then, let me know. I may send it to you if I can remember how.

Ingredients
Tortilla Wraps,
Spinach, Small Radish, Cucumber, Onion, Yellow Pepper
Rocket Salad - Lollo Bionda Lettuce, Red Batavia Lettuce, Rocket, Mizuna
Garlic, Olive Oil, Soy Sauce, Cumin Seeds, Garam Masala, Maggi Hot & Sweet Sauce
Low Fat Cheese Slices, Ricotta Cheese
Eggs and Egg Whites

Hear me squeak

2004-08-31T02:07:00.000-07:00

Squeak is a highly respected free implementation of Smalltalk based on the original Smalltalk 80 with names such as Alan Kay and Dan Ingalls (from the original Smalltalk project) involved in it. The cool thing about Squeak is that the code not only works bit-identical across platforms, but also looks the same.

I have always wanted to play with Smalltalk because there are people who I respect and personally know in the software world who do not like to work with any other language. My friend Jason, a Smalltalk hacker had given me the 10 minute introduction a while ago about the 3 types of messages is all one needs to understand.

So I decided, to try it out for real. This is more of a challenge than one thinks, because you have to change your way of thinking. However, some of the tutorials on the web were helpful.

First things first. I hate the default theme. I can't stand it. They really could make it look nicer without my having to tweak the settings. But look and feel was the last thing on my mind. So I followed a few tutorials and came to one conclusion.

I absolutely love the environment. I am not crazy about the language or syntax, even though its nicer than any of the mainstream languages. I would anyday choose Lisp over it. I miss the parens already.

The image saving is probably the best part. CL implementations also have image saves, but really it cannot compare to the way Smalltalk does it. "Inspect" and "Do It" are great, but that is something that I expect from a half decent language anyway.

My ideal development environment would probably be a Common Lisp that is really inspired by Smalltalk environments. As far as I have heard and read about it, Lisp Machines were/are like that some 20 years ago. I do not know if any of the modern Lisp environments are like that.

The Smalltalk System Browser is such an easy to use well thought out tool. I also tried the trial version of Visual Works on Mac OS X. I did not like it as much. It seemed too complicated to me after following the "WalkThru" exercise. One tip to Cincom - GUI walkthroughs suck. Show me the language first. Show me the power of iterating through a collection of objects or something of that nature. Something that lets me write the equivalent or at least close to MAPCAR in Smalltalk. Show me how to accomplish more with less code. I know it does have those capabilities and as a developer, that is what I am waiting to see.

Using CL-PPCRE for weblog search

2004-08-17T09:41:00.000-07:00

A little while ago, I wrote a search facility for my weblog. This was for personal use, and the code might be very primitive. However, here are the main functions that I used.


;;; This program depends on CL-PPCRE. It should be loaded

;;; as a package first or available in the lisp image



(defun file-to-string (file)

  (apply #'concatenate 'string

         (with-open-file (str file :direction :input)

           (loop for line = (read-line str nil 'eof)

              while (not (equal line 'eof))

              collect line))))





(defun scan-in-file (srch file)

  "scan for a single occurence of the string in the file"

  (cl-ppcre:scan srch (file-to-string file)))





;;; Takes a list of pathnames as the arg for dir.

;;; (scan-in-directory "blah" (directory "*.txt"))

(defun scan-in-directory (srch dir)

  (let ((files (loop for x in dir collect

                    (namestring x))))

    (remove-if-not #'(lambda (file)

                       (scan-in-file srch file)) files)))



;;; searches the tree below current dir.

;;; (search-in-tree "question" "*.txt")

(defun search-in-tree (srch wildcard)

  (let ((dir (nconc (directory wildcard)

                    (directory (concatenate 'string "*/" wildcard)))))

    (scan-in-directory srch dir)))





;;; Creates a url that a browser can visit

(defun create-url (file-name base-dir)

  (let ((base-url (ext:getenv "SERVER_NAME")))

    (let ((fpname (pathname file-name)))

      (let ((abs-path (pathname-directory fpname))

            (name (pathname-name fpname))

            (type (pathname-type fpname)))

        (let ((p (position base-dir abs-path :test #'equalp)))

          (let ((rem-dirs (nthcdr (1+ p) abs-path)))

            (let ((rem-path (namestring (make-pathname :directory (cons :absolute rem-dirs)))))

              (concatenate 'string "http://" base-url "/" base-dir rem-path name "." type))))))))

If someone is curious enough to try it, its here

Mini Weblog Search Feature

I've used my homegrown CGI library, although this server does have mod_lisp installed, which I would like to play with when I have time.

Increased usage of Smalltalk

2004-08-17T09:24:00.000-07:00

Over the last couple of months, I have seen many new Smalltalk jobs here in India. Placement consultants also keep contacting me about opportunities just because I have Smalltalk on my resume. The only reason it is there is because of the description of software for which we were developing a data warehouse. While I do have a passing familiarity with the language, I did not realise that there would be people working on it in India. Intringuing.

Self Publish Your Books

2004-08-01T11:40:00.000-07:00

After looking at this post via Lemonodor via Planet Lisp, I personally feel that more Lisp authors should self-publish their books on the web and serve them as downloadable softcopies. There are many sites that let people sell e-books, and I would anyday buy something that is good quality writing like Peter Siebel's upcoming book.

This will help keep more of the money in the authors pocket's (which they deserve) and hold other rights to the content that they create. There are many reasons why I think this is a better approach than using a publisher especially in a small and niche market segment like Lisp related material.

Been a bad week

2004-08-01T11:34:00.000-07:00

This last week has been horrible. I managed to corrupt my hard disk to the point where my Powerbook would not even boot. This happened just before I took my set of data backups. All the code, I could rewrite but to go back to the himalayan ranges in the east and take pictures of nature and buddist monasteries again would have been some effort.

Luckily I had YDL on a partition which came in handy, to install a new copy of Panther and access my hard disk. I managed to get all my backups done, and re-installed the OS. Now I am piecing things back together. Lets see how it goes.

This is better than that

2004-07-12T04:27:00.000-07:00

It is really interesting when people highlight different parts of the same article when they interest them. Lispers and Smalltalkers usually get along quite well. I have hardly ever seen one say a bad thing about the other. I found this rather interesting, especially the pick of quotes. This refers to quotes picked out from Ted Leung's post.

From a primarily Lisp blog.

Lisp is the number one programming language idea of all time. Smalltalk's contribution was to build encapsulation on top of the ideas in Lisp. Someone asked a question about the market voting or something like this. Kay's reply went something like this: Most people don't understand Lisp -- does that make it bad? Most people understand Maxwell's equations -- does that make them bad? One of the things that Kay is doing now is just going around and giving talks to remind people of the great ideas in Lisp and Doug Engelbart's work

From a primarily Smalltalk blog.

Much as I love Lisp, it seems to me that the Smalltalk community, led by folks like Kay, are continuing to demonstrate a convincing agenda for forward progress, while the Lisp community is perennially struggling with basic infrastructure issues like which dialect of Lisp/Scheme, which windowing environment, etc. Perhaps this is due to the conception of Smalltalk as a system, in addition to a language.

Heh?

Ayurvedic Massage

2004-07-11T07:38:00.000-07:00

So I decided to get one of the Ayurvedic massages from one of the Ayurvedic clinics here. Ayurveda is India's oldest medical science and probably pre-dates every other kind of medicine including the Chinese. The state Kerala in the south of India has become a very popular tourist destination just because of Ayurvedic treatments.

Anyway, it is quite an ordeal. The massage is extremely rigorous and tiring (not like the usual relaxing massages). They use heated medicated oils which they pour on different parts of the body depending on the treatment which is followed by a rigorous massage. This goes on for at least half an hour. Then they wipe you down steamed towels which smell like camphor.

However, it is very rejuvenating. Google for 'Kerala Ayurvedic Massage' for interesting articles and pictures on the subject. If you have not tried this, it is recommended at least once. Besides, a trip to Kerala, India can be very relaxing. Its all coastal with nice clean beaches and backwaters on which you can rent a two bedroom boat for 2-3 days with a personal chef.

Kerala is the only state in India that has achieved 100% literacy and people prefer to communicate in English, besides their local language Malayalam.

Writing LTK Extensions

2004-07-11T07:29:00.000-07:00

Tcl/Tk have some nice extension packages like Tix, BWidgets, TkTable, Tclodbc etc. Most of them can be used from the tcl (tclsh) or tk (wish) shells. I asked Peter about adding extensions to Ltk, and he has included a chapter in the latest release of Ltk (0.8.5) AFAIK. Two thumbs up to this guy for documentation and support. He has included an example for one Tix widget.

I have already started working on Ltk-odbc which will wrap tclodbc and return Lisp lists for data. It needs a lot of work as well as documenting but it has started. Watch for more on this. The next would probably be Tktable after this.

LTk and listboxes

2004-07-02T10:41:00.000-07:00

Scrolling a listbox is a common requirement in many apps. The Tk listbox widget is very useful also because one can pack huge amounts of data in it very quickly. I was planning to use it for some data display functionality. So the experimentation started with a simple scrolling listbox. The first test was this


(defun test-scroll ()

  (with-ltk

      (let* ((vs (make-instance 'scrollbar))

	     (hs (make-instance 'scrollbar :orientation "horizontal"))

	     (lb (make-instance 'listbox)))

	(progn

	  (configure vs "command" (concatenate 'string (path lb) " yview"))

	  (configure hs "command" (concatenate 'string (path lb) " xview"))

	  (configure lb "yscrollcommand" (concatenate 'string (path vs) " set"))

	  (configure lb "xscrollcommand" (concatenate 'string (path hs) " set"))

	  (listbox-append lb (apply #'* (loop for x from 1 to 100 collect x)))

	  (listbox-append lb (loop for x from 1 to 100 collect x))

	  (grid lb 0 0 :sticky "snew")

	  (grid vs 0 1 :sticky "ns")

	  (grid hs 1 0 :sticky "ew")))))

The xscrolling is redundant here but I wanted to try it anyway. Peter Herth (the author of LTk) also informed me that the PROGN is not needed. I still like to put it there anyway. So one thing I needed to try is scrolling multiple listboxes. This code has Peter's fix and the PROGN comment.


(defun test-scroll-3 ()

  (with-ltk

      (let* ((s1 (make-instance 'scrollbar))

             (lb1 (make-instance 'listbox))

             (lb2 (make-instance 'listbox)))

        (progn  ;; you do not need a progn here...

	;;; just define the tcl function by sending it to wish:

	  (ltk::send-w

	   "proc ScrollListboxes {listboxes args} {

                foreach lb $listboxes {

                        eval $lb yview $args

                }

           }")        

          ;; now configuring the scrollbar works as in tk:

          (configure s1 "command" (format nil "ScrollListboxes {~a ~a}" (path lb1) (path lb2)))

          (configure lb1 "yscrollcommand" (concatenate 'string (path s1) " set"))

          (configure lb2 "yscrollcommand" (concatenate 'string (path s1) " set"))

          (listbox-append lb1 (loop for x from 1 to 20 collect x))

          (listbox-append lb2 (loop for x from 1 to 20 collect x))

          (grid lb1 0 0 :sticky "news")

          (grid lb2 0 1 :sticky "news")

          (grid s1 0 2 :sticky "ns")

          (listbox-append lb1 (loop for x from 21 to 40 collect x))

          (listbox-append lb2 (loop for x from 21 to 40 collect x))))))

And based on this, I came up with this for data display


(defun data-display (colnames data)

  (with-ltk

      (let ((ld (length colnames)))

	(let* ((df (make-instance 'frame))

	       (lbs (loop for i from 1 to ld collect (make-instance 'listbox :master df)))

	       (sb (make-instance 'scrollbar :master df)))

	       (ltk::send-w

		"proc ScrollListboxes {listboxes args} {

                    foreach lb $listboxes {

                            eval $lb yview $args

                    }

              }")        

	       (mapcar #'(lambda (lbox)

			   (configure lbox "yscrollcommand" (concatenate 'string (path sb) " set"))) lbs)

	       (configure sb "command"

			  (format nil "ScrollListboxes {~{~a ~}}"

				  (mapcar #'(lambda (lb) (path lb)) lbs)))

	       (wm-title *tk* "Result Set")

	       (configure df "width" 800)

	       (configure df "height" 600)

	       (pack df :expand 1 :fill "both")

	       (loop for y from 0 to (1- ld) and name in colnames do

		    (let ((lbl (make-instance 'label :text name :master df)))

		      (grid lbl 0 y :sticky "w")))

	       (loop for y from 0 to (1- ld) and lbx in lbs do

		    (grid lbx 1 y))

	       (grid sb 1 ld :sticky "ns")

	       (loop for y from 0 to (1- ld) and lbx in lbs do

		    (listbox-append lbx (mapcar #'(lambda (row) (nth y row)) data)))))))

This can be called as shown below. The two args are the field names and the data. Buggy but functional.


(data-display '("foo" "bar" "baz") '((a b c) (d e f) ("blah" "blah" "blah")))

Now, if only I can figure out how to limit this from jumping of the screen and proper horizontal scrolling, it might be more useful

What is a Lisp Machine?

2004-06-27T00:59:00.000-07:00

Lisp Machines fairly well known in the Lisp world, however, even Lisp seems foreign to most people, including programmers. Lisp machines were common in the 1980s and are still considered one of the most productive developer environments and user experiences. Everything else is still playing catch up which is ironic.

One common phenomenon in the Lisp space recently is Lisp based weblogs. They have been on the rise as one would notice from the aggregation at Planet Lisp. Even my weblog which was intended to be just another blog on the web has a very uneven ratio of Lisp vs other topics.

Glenn Ehrlich is another Lisp blogger. What is very cool about Glenn's postings is that he actually has a Lisp Machine which he purchased recently. He has answered the Lisp machine question rather well here.

He has some really good posts about his user experiences with his LispM.

Searching Entries On My Weblog

2004-06-25T09:28:00.000-07:00

Sometimes one has a need to go back and read ones own weblog entries. The standard blogger template that I have did not seem to have that functionality. After I encountered cl-ppcre, I knew I wanted to use it for something. So I hacked together a little program that searched for regular expressions in html files that are generated for this blog. If anyone would like to test it its here.

Mini Weblog Search Feature

It searches for Perl style regular expression matches on the html sources for the weblog. Try it out. I did have problems with the character sets. Thanks Thomas for helping me with that. It does have limitations. It reads the entire file into a string before doing the matching and searches for a single occurence of a match in the string. So the ^ and $ directives would be useless in most patterns here.

My Road To Lisp

2004-06-22T13:16:00.000-07:00

This is something that I wanted to do a while back. However, I never got to finishing it on time. When I did, I had some problems uploading it to the site. Kenny Tilton was very kind to help me with that. Thanks Kenny. If anyone is interested, it is here.

Regular Expressions with CL

2004-06-20T23:56:00.000-07:00

Regex or regular expression search capabilities have become quite common now. They are a major factor in the popularity of Perl on *nix based systems. Perl has a highly optimized regex engine, written in C, and usually outperforms most others. Some CL dialects also come with their own regex engines like Clisp with the "REGEXP" package. However, using that would result in non-portable expressions.

So there is CL-PPCRE, or Portable Perl Compatible Regular Expressions for CL. For me the real test of any piece of open source software is how easy it is to get, install and use. CL-PPCRE was a breeze to install. The easiest way is untar the files to a location and then run

(load "load.lisp")

which takes care of all compilation and loading. I tested it with Clisp, Openmcl and SBCL on Mac OS X and it worked fine. Since it is written with ANSI CL, it should function with any compatible CL dialect, which makes it extremely portable. It also comes with MK:DEFSYSTEM and ASDF packaging if you prefer to install it that way.

Since it is so useful, I did an image save with Clisp and copied over my current Lisp image. This is with Clisp.

(ext:saveinitmem)

which saves the image file to lispinit.mem. I replaced my current lispinit.mem startup file with this which has my original lisp image + cl-ppcre. My lisp image resides in /sw/lib/clisp/full/. You can also always start clisp by pointing to an image file.

# clisp -M lispinit.mem

Most Common Lisp's have an image-save function, so it would be easy to replicate this. Once you have cl-ppcre, it has two packages - cl-ppcre and cl-ppcre-test. cl-ppcre has all the common regex functions like scan, replace, split etc.

When compiled with CMUCL, it outperforms Perl in most cases. This is one great package.

(preferp 'language 'CL) => T

2004-06-20T23:54:00.000-07:00

We had switched to PLT-Scheme as our platform a few weeks back for some simple reasons, mainly because of the available libraries and the cross-platform implementation. However, there are things about that environment that really caused us problems, mainly, because we have been spoilt by Common Lisp.

The most irritating thing of the PLT-Scheme environment, DrScheme is the disconnect between the editor and the REPL. One of the best things about CL is loading functions into the environment on the fly. Once you load your test data in memory, and you have a test environment set up, there is no need to do that again.

It is common practice to write and rewrite functions in the running environment. This makes it extremely productive. With the open source/free CL implementations, Emacs with Ilisp or Slime is the environment. The commercial ones come with their own which are also pretty good, maybe even better.

This can be due to our own lack of knowledge of PLT-Scheme. We found the "Execute" button to be our enemy. When you press "Execute" it reloads all the current definitions into a new environment after resetting it. This in effect reduces the environments productivity levels to that of non-interactive languages.

We decided to switch back to CL, despite the issues we had with the open source and free implementations. We already find that it is a better programmer environment, at least for us. In future if an when we decide to switch to a commercial CL, the transition will also probably be easier than from Scheme.

Lisp + Tk = LTk

2004-06-17T00:30:00.000-07:00

Tk is quite a popular cross platform GUI library and Tcl and works identically across most platforms. Languages like Perl and Python use it as their standard GUI library with libraries like PerlTk and Python Tkinter. Over time many Lisp bindings have been written by passing Tcl commands over a stream to wish (The Tk interpreter). That however, required knowledge of Tcl.

Now there is LTk (currently in version 0.8) written by Peter Herth and is written entirely in Common Lisp with Lispy bindings to most Tk widgets. It lets you write an entire GUI application in Lisp.

The Lispy syntax is what makes LTk unique. Installing LTk is extremely simple as most of the code is in one file called ltk.lisp. The with-ltk macro sets up communication with Tk via a stream. LTk also comes with remote-ltk that lets you communicate from Lisp to Tk via a socket.

Installing LTk is as simple as firing the following commands from your Lisp REPL, provided you have Tcl/Tk (wish) installed.


(compile-file "ltk")

(load "ltk")

(use-package 'ltk)

(test)

If the test function runs without a problem, you should be all set. It also comes with an ASDF package if you prefer that. Please send feedback and patches to Peter so that this already nice package can be improved upon. Thanks again Peter.

The Olympic Flame Passes Through India

2004-06-10T11:02:00.000-07:00

The olympic flame made its way to the capital of India, New Delhi. It was passed on the streets by runners today, from person to person. The sad thing was that there were more celibrities and politicians who were carrying the flame than actual and past and current athletes. The only saving grace was a bunch of cricketers but that is not an olympic event. As Milkha Singh (the flying sikh) said, the flame should have only been carried by athletes who have or will participate in the olympics and all the celebrities who wanted to participate could have run with them. It would have been the right thing to do. I cannot agree more. As always, the politicians and celebs in the country have diluted the significance of this historic event.

A Range Function

2004-06-09T19:00:00.000-07:00

The range function in Python is quite useful for generating lists of numbers quickly. It is often used with 'for' as a basic iterative construct. The same effect can easily be achieved with Lisp and the Loop macro. Here is an example of how range works


Python 2.2.3 (#1, Nov  8 2003, 23:39:13) 

[GCC 3.3 20030304 (Apple Computer, Inc. build 1493)] on darwin

Type "help", "copyright", "credits" or "license" for more information.

>>> range(5)

[0, 1, 2, 3, 4]

>>> range(2,10)

[2, 3, 4, 5, 6, 7, 8, 9]

>>> range(2,10,2)

[2, 4, 6, 8]

>>> range(-10,-2)

[-10, -9, -8, -7, -6, -5, -4, -3]

>>> range(-10,-2,2)

[-10, -8, -6, -4]

>>> def square (x): return x * x 

... 

>>> square



>>> for x in range(5): print square(x)

... 

0

1

4

9

16

>>>

Here is my Lisp function for the same using Lisp with Loop


(defun range (n &rest parms)

  (case (length parms)

    ((0) (loop for x from 0 to n collect x))

    ((1) (loop for x from n to (first parms) collect x))

    (t (let ((start n)

             (stop (first parms))

             (step (second parms)))

         (loop for x = start then (+ x step) until (>= x stop)

              collect x)))))

Its a little different because I have inclusive of the highest number. That is the easiest thing to modify. here is a test


[6]> (range 5)

(0 1 2 3 4 5)

[7]> (range 2 10)

(2 3 4 5 6 7 8 9 10)

[8]> (range 2 10 2)

(2 4 6 8)

[9]> (range -10 -2)

(-10 -9 -8 -7 -6 -5 -4 -3 -2)

[10]> (range -10 -2 2)

(-10 -8 -6 -4)

[11]> (defun square (x) (* x x))

SQUARE

[12]> (loop for x in (range 5) do (print (square x)))



0 

1 

4 

9 

16 

25 

NIL

[13]>

The Loop macro is much more powerful than the usage shown here but it can look ugly from a Lisp perspective.

More Format Directives

2004-06-05T10:12:00.000-07:00

A friend of mine Jorg Preisendorfer, came across my entries on format directives. The modifiers for iteration as mentioned in section 22.3.7.4 of CLHS. I had discovered "~{" and "~}" directives. Here are the more elegant rewrites.

My code


 (format t "~{~{~A~%~A~%~}~}" '((a b) (c d) (e f) (g h)))

The better version


 (format t "~:{~A~%~A~%~}" '((a b) (c d) (e f) (g h)))

More succinct, and easier to write. The colon performs the iteration on sublists.

Another directive that I had discovered was "~R" which prints a number in the English formulation. I had also requested a Loop version mainly because of my inexperience with Loop. Here is the code.


  (loop for x = (expt 10 9) then (* x 1000)

   		until (>= x (expt 10 66))

   do (format t "~R = ~:*~A~%" x))

The directive "~:*" directive is also very interesting as mentioned in section 22.3.7.1 of the CLHS.

Thanks for the responses Jorg.

Understanding Scheme Continuations - Part I

2004-06-03T22:31:00.000-07:00

Scheme is one of the languages that has built in support for continuations. Sometimes understanding them is a little difficult because of the way they have been explained. The best way to explain them is by example. In Scheme the call-with-current-continuation is one way to use them. This is also abbreviated as call/cc.

The call/cc procedure is passed a function of one argument and that argument is called the current continuation.

One common example used is


(+ 1 (call/cc

       (lambda (k)

         (+ 2 (k 3)))))

In this example there are a couple of things that are important to understand. Firstly the continuation can be explained as

(+ 1 something)

The call/cc part binds a continuation to k and the argument 3. The + 2 is completely ignored. As shown here. Any computation outside of k will be ignored.


 (equal? (call/cc (lambda(k) (+ 2 (k 3)))) 

         (call/cc (lambda (k) (* 10 (k 3))))) ==> #t

Hence (+ 1 something) ==> (+ 1 3) ==> 4

This is a very simple example of an exiting or escaping continuation. It is useful to use when you want to exit a program in between a recursive loop because of some condition. An example is a list-product function. Written recursively, it gets each element from the list and multiplies it. A continuation could be used to exit when encountering a 0 element, since that automatically means the computation would be 0. Without the exit, the computation will continue unnecessarily.

Declaring a continuation globally can help one reuse it many times, which makes the 'rest of the computation' available for reuse. Taking the same example and modifying it a little.


(define r #f)



(+ 1 (call/cc

       (lambda (k)

         (set! r k)

         (k 3))))

This is when it becomes interesting. The continuation as usual will return 4 when executed the first time. But now it is stored in the global variable r and can be called from the top level with any value.

So

(r 3) ==> 4
(r 10) ==> 11
(r 0.1) ==> 1.1

The critical thing to understand here is that, this is not a function but a continuation. That can be illustrated by

(+ 3 (* 10 (r 5))) ==> 6

As shown above, it abandons the context that surrounds it.

Now we'll take a slightly more interesting example. A simple function that evaluates 2x^2 + 3y + 1. We will bind x and y to continuations.


(define r1 #f)

(define r2 #f)



(define (somefunc x y)

  (+ (* 2 (expt x 2)) (* 3 y) 1))



(somefunc (call/cc

           (lambda (c1)

             (set! r1 c1)

             (c1 1)))

          (call/cc

           (lambda (c2)

             (set! r2 c2)

             (c2 1))))

This example will show how the continuations remember the previous values. To start with it will call (somefunc 1 1) and set the values of x and y as 1 and 1. Everytime we call the continuations r1 and r2, it will record the previous value and use it to compute somefunc.

(r1 5) will compute (somefunc 5 1) and return 54. This will also record the value of x as 5. Now calling (r2 5) will compute (somefunc 5 5) and return 66. Now both x and y have been recorded as 5 and 5. This process will continue for as long as r1 and r2 are called.

Go Figure?

2004-05-29T12:21:00.000-07:00

The elections are over. The new government has been formed with some on the inside and a large part supporting the coalition from outside. Dr Manmohan Singh is our new prime minister. A very talented and accomplished economist, he is certainly deserving.

The interesting tidbit here is that he was born much before 1947, the year of the partition of India and the formation of Pakistan. The place that he was born, is now in Pakistan, and the place that Pakistani President General Musharraf was born, is now in India.

Leaders of two countries born across borders ... Interesting?

Choosing a dialect ...

2004-05-24T03:40:00.000-07:00

Choosing a Lisp dialect to learn is easy. Pick any Lisp or Scheme dialect and some tools and start. So far the best combination of tools in the scheme space is DrScheme which will run on most platforms or for Common Lisp, Get Clisp and configure Emacs + Ilisp. These are by far the easiest ways to start in the free tools space. The commercial vendors offer excellent tools as well like Xanalys Lispworks which is adequate in its cross-platform implementation or Franz Allegro CL which offers excellent tools especially on Windows. The commercial vendors offer trial versions for educational and learning purposes and are good tools.

Choosing a Lisp dialect for commercial development is entirely a different ball game depending on where you are from. There are very few Common Lisp vendors who would qualify as affordable especially for a tiny startup with 2-4 developers. The two major competing folks are the Xanalys people and the Franz people both who have priced their product according to the American and European markets. Xanalys Lispworks Developer Edition starts at USD 900 and allows unlimited production of royalty-free runtimes. If I was in the US, this is extremely competitive and very affordable.

However, the fact is that I sit in India. A friend of mine and I are in the process of developing a product for a particular market segment in my country. The difference of money in terms of USD and INR (Indian Rupees) fluctuates between 43 to 46 Rupees to a Dollar depending on many factors. There is only a certain reasonable amount that I can charge a customer in India for a product to have both a happy customer who sees value in what I deliver and get more customers to find my product attractive enough for them to invest in it.

This really restricts my budget to the open source and free software segment that allows or encourages commercial development. This can also be done with the GPL tools which give a user more freedom, but is very unattractive for developers in a small niche market segment. The BSD or LGPL tools have more freedom for the developer in terms of choice of product licensing but that is another debate altogether.

After reaching the conclusion that we needed free tools for our development, we also needed to reevaluate our need for a Lisp like language and if we could not just go with C, C++, Java or C# like the rest of the world. We even considered Python because it has some strengths that it inherited from Lisp and is very easy to learn. Being a tiny team, starting with two programmers these decisions are easy, because we do not care about what Gartner says and will almost always do exactly the opposite.

All the Lisp and Scheme dialects satisfied our major requirement for the language to have the power to let us manage and modify complex data structures easily by their very nature. My main working platform is an Apple Powerbook with Mac OS X 10.3. My partners is a Debian GNU/Linux machine which runs Windows 98 on one partition but that seldom gets an opportunity to show its face. Most of our clientele will be running Windows. Suggesting that they migrate to Linux/BSD would be unfair to them. For us to invest in newer Windows machines would be a problem because absolutely any expense will eat into our potential profits which at the time of starting is 0 to begin with and negative if you consider programmer time expensive. Our real fun with Lisp is writing macros, for which we were hesitant to move to something else and also familiarity with the language.

I had been exposed to the PLT-Scheme environment via DrScheme and knew it ran well and is reasonably cross-platform. So I decided to investigate the PLT-Scheme family of tools. DrScheme is a fairly usable IDE with Emacs like key-bindings. It has a powerful module system which looks very much like the CL packaging system. It has GUI bindings via MrEd to the wxWindows library. It has an ODBC layer via SrPersist and a lot more. On top of all this, it is distributed with an LGPL license.

Based on our requirements and our restrictive situation, we really welcome the availability of PLT-Scheme. It is certainly an environment that open-source Common Lisp dialects should strive to become both in terms of cross-platform development and libraries. Some commercial Lisp dialects would have suited us beautifully but for their "American" prices. Maybe some people will accuse us of wanting to drive a Ferrari without having the money for it *grin*.

Discovering Format Directives

2004-05-17T09:39:00.000-07:00

So I was just reading some Common Lisp information on the web when I saw these really cool code examples in Peter Siebel's excellent book "Practical Common Lisp" that uses format. I have used format but had not realized how cool it really is.

The first very interesting example used the "~{" and "~}" directive which lets us use nested lists as parameters to format. I decided to test this on my own for an understanding


[30]> (format t "~{~{~a~%~a~%~}~}" '((a b)))

A

B

NIL

Looks good. So I tried


[34]> (format t "~{~{~a~%~a~%~}~}" '((a b) (c d) (e f) (g h)))

A

B

C

D

E

F

G

H

NIL

Even better. So if it supports nested lists, then it should obviously allow more nesting and so I tried


[35]> (format t "~{~{~{~a~%~a~%~}~}~}" '(((a b))))

A

B

NIL

[36]> (format t "~{~{~{~a~%~a~%~}~}~}" '(((a b) (c d))))

A

B

C

D

NIL

Yup. As usual in impressive Lisp style, my REPL responds as expected. So I was pretty happy about learning something new, thanks to Peter Siebel, I read further down and finally ended up in the footnotes section where I found this gem.


[37]> (format nil "~r" 1606938044258990275541962092)

"one octillion, six hundred and six septillion, nine hundred and thirty-eight sextillion, 

forty-four quintillion, two hundred and fifty-eight quadrillion, nine hundred and ninety 

trillion, two hundred and seventy-five billion, five hundred and forty-one million, nine 

hundred and sixty-two thousand, ninety-two"

Holy mother of batman! That is bloody impressive for a function I have so far only used for printing. Note to self -> ALWAYS READ FOOTNOTES. Anyway, curious about how much it would take, I figured that Clisp can take a max of One Hundred Vigintillion which is 10^66. So guess what I had to know all the intermediate names.


[38]> (do ((x (expt 10 9) (* x 1000)))

    ((>= x (expt 10 66)))

  (format t "~r = ~a~%" x x))

one billion = 1000000000

one trillion = 1000000000000

one quadrillion = 1000000000000000

one quintillion = 1000000000000000000

one sextillion = 1000000000000000000000

one septillion = 1000000000000000000000000

one octillion = 1000000000000000000000000000

one nonillion = 1000000000000000000000000000000

one decillion = 1000000000000000000000000000000000

one undecillion = 1000000000000000000000000000000000000

one duodecillion = 1000000000000000000000000000000000000000

one tredecillion = 1000000000000000000000000000000000000000000

one quattuordecillion = 1000000000000000000000000000000000000000000000

one quindecillion = 1000000000000000000000000000000000000000000000000

one sexdecillion = 1000000000000000000000000000000000000000000000000000

one septendecillion = 1000000000000000000000000000000000000000000000000000000

one octodecillion = 1000000000000000000000000000000000000000000000000000000000

one novemdecillion = 1000000000000000000000000000000000000000000000000000000000000

one vigintillion = 1000000000000000000000000000000000000000000000000000000000000000

NIL

I had a "for" loop macro construct that I used to use for simple stuff but realized I need to modify it after this example and had to get into a "DO". I would appreciate if someone can show me how to do this with the "LOOP" macro.

Coolie Valley?

2004-05-13T21:40:00.000-07:00

I had read this article on rediff a couple of months ago via a link on slashdot and wanted to comment on it. The comment section looks like everyone in the world had an opinion. Well I decided to join the world.

Coolie is a Indian term which refers to a porter at a place of public transportation like a railway station. I have no idea why people refer to them in a denigrating fashion. After all they are doing a very nice job. Imagine you are 65 and have a good amount of luggage. What harm is there in paying someone to carry it?

Getting back to the article it stresses that India does not bet on innovations. This is something I disagree with, however, not entirely.

The majority of companies in Bangalore provide a service. They provide an army of cheap programmers for a fee. I do not see anything wrong with that. There are R & D outfits of some major companies in India as well, albeit, in a smaller number. The fact is that services is a huge market and business is about making money. Even a company like IBM, which cannot be called "not innovative" is focusing on services as a sector.

As far as patents in software are concerned, I believe they should not even be allowed, but thats my personal opinion, although, I have nothing against intellectual property.

India as a country has developed supercomputers, ICBM's, nuclear weapons, Satellite Launch Vehicles, Linguistic software and many other things indigenously. None of these were originally created by them, so they were not responsible for the idea. They however, are responsible for the technology inside these which are in most cases unique. It would be prudent to also point out that India invented the zero and the basis of quite a bit of mathematics. Albert Einstein said, "We owe a lot to the Indians, who taught us how to count, without which no worthwhile scientific discovery could have been made."

I do have issues with the term "Silicon Valley of the East" basically because it is a mimicry of the West which we need not do for everything. Bangalore is neither a valley nor a city of silicon, which, was initially associated with companies manufacturing hardware.

As far as innovations are concerned, yes, Silicon Valley is ahead but lets not forget what should not be considered an innovation in the software sector which is attributed to companies like Sun, Apple, IBM etc.

1) Virtual Machine - Popularly recognized as something done by Sun, this was originally done in the early 60's with Lisp and later with Smalltalk. Lisp and Smalltalk both have superior VM architecture to Java despite being languages that are over 20 years old.

2) Garbage Collection - This is something that was necessary for C programs to run stable. There are many many languages with very good garbage collectors all dating way before Java was even concieved.

3) GUI - Usually attributed to Apple, this was originally developed at Xerox Parc, a place where a lot of innovations came from. The mouse also came from Xerox.

4) OOP - Xerox Parc again with Smalltalk. Even today Smalltalk is a better language than Java, C# or C++ which are the 3 most popular OOP languages, however, because of its diminishing popularity it has less libraries which can also be said of Lisp.

5) Frameworks - CORBA begat COM that begat DCOM that begat .Net. J2EE also emerged from this pile. It is standard practice in OOP as well as functional languages to build frameworks first. Developers in these languages are used to it. There are many well known frameworks in other languages as well although they do not try to sell things based on marketing and world domination.

What I am trying to say is that just because a company exists in Silicon Valley does not mean its innovative, just like companies in India are not necessarily just cheap labour as the article points out. Managers reading Gartner reports really do not help with that either which covers most of the US as far as innovation is concerned.

Clisp directory handling

2004-05-12T02:19:00.000-07:00

The main problem with Lisp implementations, is the open-endedness that they have left for certain portions of the implementation. A very good example is the "directory" function which works differently on different flavours of CL. This is despite the fact that it has been listed in the CLHS. Some of the variance also probably comes from the different operating systems, which have their own representations. I mainly use Clisp for portability across OS's. The other ones like CMU CL, SBCL, OpenMCL, Corman Lisp etc are ahead in some respects and offer native code compilation but are way behind on portability.

On Clisp just typing

(directory)

will list all files in the current directory

(directory "*.txt")

will list all files with a .txt extension in the current directory

(directory "/usr/local/apache2/cgi-bin/*.lisp")

can be used for a specific directory.

(directory "*")

fortunately works with most flavours.

(directory "*/")

Will list only sub-directories. This can be useful for some system programs. To get a listing of everything in a directory including sub-directories in Clisp

(append (directory) (directory "*/"))

nconc can also be used instead of append.

There is a lot more information available here. I was very happy to read that Clisp does have these despite the fact that many people criticize it for some things.

Understanding Symbols and Variables

2004-05-10T12:08:00.000-07:00

I was chatting with a friend of mine about some code that we are writing for a project and the discussion of symbol-value came up. I had a hard time explaining symbol-value mainly because I chose a wrong example to begin with. The best part about Common Lisp or any other interactive language is that you can try everything the moment you think about it.


(setf x 'a)



(setf (symbol-value x) 'b)

The two statements are the simplest explanation. The first is creating a global variable x and binding the value 'a to it. The second statement is more interesting because it lets me set the value that was retrived from x to something, in effect, creating a global variable -> a and binding the value of -> a to 'b.


(setf (symbol-value x) 'b) => (setf a b)

Because of the current binding of x. This feature of Lisp will let me assign a global dynamically. Feel the power? No ... check out the set-var-from-string macro here.

Dangerous Tomatoes?

2004-05-09T19:38:00.000-07:00

I have stopped eating tomatoes. It all started with the Eat Right 4 Your Blood Type diet which I tried after watching my cousin have quite a bit of success with it. My blood type is B (Rh factor is immaterial on this diet) and I learnt that tomatoes contain a lectin that can be dangerous and type B's should avoid anything with tomatoes in it. Yikes, that means no ketchup.

Anyway, after i stopped eating tomatoes, my acidity problems disappeared and the occasional acid reflux is gone as well. The interesting thing is that its the same story with my father (type B) and my younger brother (type O).

Being brought up in a culture where fruits and vegetables are regarded as healthy food, especially tomatoes, it was more difficult mentally. Interestingly, all the heartburn medicine commercials show people eating pizza or pasta or something very tomatoey. Interesting?

The unexplored Eastern India

2004-05-07T00:11:00.000-07:00

Arunachal Pradesh is India's extremity on the Eastern side. It is an unexplored beautiful region at the foothils of the Himalayan and Shivalik mountain ranges. This area is where the maximum Buddhism in current day India can be found with monasteries all over the region including the Tawang monastery at Tawang.

I had the good fortune of visiting Arunachal earlier this year and have captured some of my moments on camera.

Itanagar is the capital of Arunachal and this is a view from the room window of Hotel Donyi Polo Ashok. I really had to scale the image down because of its actual size from my 6.3 Megapixel camera. Now back at Pune, I do miss the fresh air of Arunchal already.

Passing variable arguments of a function

2004-05-05T22:52:00.000-07:00

Yesterday I was struggling with the &rest parameter, mainly due to my
ignorance and inexperience. I have used the &rest parameter in the
past and it works very easily. For instance, the function below will
just return its arguments. The &rest parameter is very useful in case
of variable arguments.


(defun foo (&rest args)

  args)

Evaluating the following


(foo 1 2 3) => (1 2 3)



(foo 'a 'b 1 2) => (a b 1 2)

Even though I have used this in functions before, I was having
problems passing the &rest arguments of one function to another. So I
jumped on the #lisp channel and asked the experienced folks there,
and they said, just use 'apply', and the bulb in head lit up, of course.

Here is a very simple example of passing the &rest parameter to the
&rest of another funtion.


(defun add (&rest args)

  (apply #'+ args))



(defun sub (&rest args)

  (apply #'- args))



(defun mul (&rest args)

  (apply #'* args))



(defun div (&rest args)

  (apply #'/ args))



(defun basic-calc (fun &rest args)

  (apply fun args))

Now evaluating


(add 1 2 3) => 6



(basic-calc 'add 1 2 3) => 6

I have used APPLY and FUNCALL many times without realizing the
implications of how powerful these are. The solution is so simple
that it never comes to mind.

Lisp Macros Rock

2004-05-03T04:30:00.000-07:00

Lisp macros are the one feature that distinguish it from almost all other programming languages on the planet. For the benefit of people who would not understand, I shall make an attempt to explain them. Consider a programming language as a tool for feeding a set of instructions to a computer. This can be interpreted or compiled and then called. The call (usually functions) will try to either just perform something or return values after some processing.

Lets take addition on a calculator. So you press 1, +, 2, = and expect it to read out the result 3. The + is a good example of what a function could be. In this instance, it expects two arguments, which are numbers. The two arguments are your variables, which, we shall name x and y. So the value of x or y can be anything as long as it is a number. Anytime you enter x + y, The function + performs its operations and returns the result. Most programming languages work the same way in the most basic sense. So there is a translation layer between the expression and the machine which tells the machine what it is reading. So

Expression -> Interpreter -> Result

Compilers just add another layer to this, often reducing the time of the last phase.

Now imagine you can change what the interpreter or compiler sees at runtime. These are called macros.

Expression -> Macro Translation -> Interpreter -> Result

Lisp macros are like Lisp functions that generate Lisp code and then evaluate them as well. Where is this useful is what most people ask. Well, for one, creating your own language on top of Lisp especially domain related. I am currently writing a persistent database query system in Lisp and one of the macros that was really needed was something that can parse a string, say "var1", extract its symbol value, var1, create a global variable by that name var1 and assign some value to it.

The macro looked somewhat like this


(defmacro set-var-from-string (str val)

  (let ((var (gensym)))

    `(let ((,var (coerce (read-from-string ,str) 'symbol)))

       (setf (symbol-value ,var) ,val))))

I can call this as follows

(set-var-from-string "var1" "test")

Which will create a variable var1 and store the value "test" in it. I could also call it from a variable

(setf x "var2")

and then call

(set-var-from-string x "test2")

This call wil create a variable var2 and store the value "test2" in it. I encourage you to try to write an equivalent of this macro in any other non-lisp like language.

Here I go Again

2004-05-03T04:21:00.000-07:00

So I figured that after taking so much time, between actually trying to write blog content and trying to write blogging software in my favourite programming language (Common Lisp), I should actually start blogging. So here goes, this is a first. Hopefully this will also give me a decent idea of designing weblogging software, considering that Blogger has been very popular.