One of the things I have learned just today is that loops are actually allowed in Lisp. All of the recursive thinking I’ve been doing lately has made me think that there’s always a way too write a loop in a recursive manner. But, I was looking at Neville’s Method the other day and it struck me that with it’s nested loops, that could be quite a challenge to write it in a recursive manner. While trying to find an example of nested loop in Lisp, I found all kinds of cool links I thought I would share:

• Lisp style tips for the beginner
• Successful Lisp
• CLMath

Go check them out, they are great resources!

To that end I’ve been working my way through the book The Structure and Interpretation of Computer Programs which is a dense volume that is chock full of good knowledge about how computer programs work from a critical and analytical point of view. The language the book uses is Scheme which is a variant of Lisp.

Having worked with XEmacs and its version of lisp (called appropriately elisp), I thought I would be able to pick up Scheme pretty quickly. This is pretty much true, since the two languages have the same general syntax/form. One thing I don’t have those is a Scheme interpreter! I did install SBCL and CLISP a while ago, so I figured that I would just use that.

Well, it turns out that Scheme is also slightly different than Common Lisp. But thanks to Peter Seibel and his excellent book “Practical Common Lisp”, I was able to translate the first few programs in the SICP so that they would run in my CLISP-Slime environment.

So if you find yourself in this situation, be sure to check out the best Common Lisp tutorial on the net. Its free and it is very well written, so I highly recommend it. I remember playing around with it a while ago, and being impressed with it back then. The good news is it is still as good now as it was then.

When it comes to rules, there are several places and ways you can encode them in your application, each with its own pro’s and con’s. Lately I’ve been reading a lot about Lisp based languages and every now and then I’ll read a reference to using Lisp code not only as a configuration file, but as a “executable” that carries its own data.

The more I thought about this, the more I wondered if this type of separation was possible in Java. Sure, I could just code the rules in Java, but where’s the fun in that? Via its reflect package, Java can do some pretty neat tricks, so I decided to try and code up some ideas in Python first since its so concise (and can also do reflection, etc.). Basically a case of “anything you can do, I can do better”.

A while ago I read a really interesting article about the visitor pattern. Most of the time this pattern is explained in terms of something like a driver: You have some kind of hardware that needs to call a driver to setup its connection to the system. Using the accept() and visit() methods you can make a class that can register itself with the caller and allow it to configure itself, the end result being that the caller doesn’t need to know (i.e. be linked with) the details of the visitor.

It occurred to me that this is the same situation with externalized business logic: The rule engine is reading in an external file and then based on the contents of that file, executing code. If a “rule” implemented the visitor pattern, and the “rule engine” implemented the accept(visitor) method, then this would allow the external file to dictate what the program would be doing without the program needing massive changes to alter the rules.

It boils down to this: defining the core actions separately from the rules allows a better separation between  the two. The visitor pattern allows the two to be bound together. The end result is cleaner (smaller) code, that should be more “testable”. At least that’s my theory.

I’ve put the python code implementing this up on my project page (here is the code). Its a very simple example, there is one rule per line, and the first token (space delimited) is the function to call followed by its arguments. Internally the RuleEngine class is calling Python’s eval() function and that is what actually executes the function from the data.txt file.

For the function to execute successfully it needs to exist (i.e. it needs to be defined in the file, or be a built-in Python function). Note that this is not the safest approach, it will allow malicious code to execute. A more secure way to do this would be to set up a dict (or, if this is done in Java a HashMap) that contains a mapping between the rule tokens and the function to be executed. That way the execution of the RuleEngine can be controlled somewhat, in that it will only allow certain functions to be executed.

At any rate, today on Reddit there were a few really good postings on this topic and one of those postings led me to more really good articles on the topic. (As a side note, I’m really glad this happened today, lately reddit has been a dumping ground for picture links and other uninteresting things.)

While none of these links shows exact methods for implementing business rules, they are a great starting spot.

• Stevey’s Home Page – The Emacs Problem

• The Fishbowl: Dear XML Programmers…

• SISC – Second Interpreter of Scheme Code

These links also mention a lot about XML and the associated headaches that come with working with it. As one of them pointed out when you (modern programmers) think about storing data, XML usually springs to mind first. Past experiences with XML and XSLT have left a weird taste in my mouth: They seem like they are on to a good idea, but the execution and use of it just feels so contrived. These articles enlightened me to think about the data with more of a functional “lisp” frame of mind.

Lots of food for thought. Lately I’ve been thinking a lot about the MVC pattern and how it is trumpeted all over the place, yet sometimes it doesn’t seem to solve the core problem of getting the application out the door to the user in a timely and maintainable manner. (And when I say that, I am thinking mostly of web apps.) Perhaps this is a better way…

After looking at that for a while I tried googling for some other examples and found this really awesome Lisp in Python implementation.

Every so often I’ll think to myself “Wow, how hard can it be to make a language?” Then I’ll remember that it can be pretty damn hard (actually I remember my Programming Languages Concepts class, then I get the shakes thinking about all of the edge cases and other complications that you have to keep track of). Seeing something like these links is really educational for me, I get to see how two similar languages have been implemented (and thanks to the comments on programming.reddit.com) and how they could have been done differently.

With all of these changes coming around, I’m thinking that in the near future we programmers are going to have to start changing how we write our programs. We can no longer depend on gigahertz increases to drive the software faster. A point has been reached where the software needs to step up and be more efficient and utilize the new hardware more effectively.

Along those lines, I ran across this very cool article today: Functional Programming For The Rest of Us

Its a really good overview of functional programming and its many advantages (concurrency, etc.). With a lot of attention being placed on “functional” features in languages like Ruby, Haskell, Python, etc. this article is a good primer on what functional programming can do for you.