A more current blog is in the works. This blog will explore ideas in many languages and systems.

Hopefully you will be able to use these ideas below to learn something or even take them to the next level.

Feel free to leave me some comments. Thank You!

Exploring an extension to a basic unit testing framework. The extension encapsulates the idea of unit-tests wrapped by a test-fixture.

• Dog-fooding a Domain Specific Language (DSL); creating an extension to lisp-unit
• Update to test-fixture

Exploring a lightweight object-oriented type in Common Lisp.

• An Object in Lisp. Part 1
• An Object in Lisp. Part 2
• An Object in Lisp. Part 2 Addendum
• An Object in Lisp. Part 3
• An Object in Lisp. Part 4
• An Object in Lisp. Part 5
• An Object in Lisp. Part 6

Exploration of an event driven system in Common Lisp.

• Event Driven Architecture Programming in Lisp Part 1
• Event Driven Architecture Programming in Lisp Part 2

An efficient methodology for me when working with lightweight objects.

• Object Programming in Lisp Observation #1

Tools and explorations that were used for the above projects.

• object.zip
• lisp-unit-with-fixture
• coverage-runner
• presenter-first
• mock

Some examples of models of computation include General Recursive Functions, Turing Machines, Lambda Calculus, Finite State Machines, and Production Systems. These are only some models of computation.

Martin Fowler has a pretty good post on rules engines (production system). “… providing an alternative computational model.”

Wikipedia’s definition is “A model of computation is the definition of the set of allowable operations used in computation and their respective costs.” I myself like the definition provided by “The Computational Beauty of Nature” [p27]. “… a model of computation describes how to build recipes or, if you like , a recipe for recipes.”

Both definitions seem to define two different things. The first definition describes programming languages. The second describes meta programming. These two definitions are not mutually exclusive. All programming languages have some form of meta programming. Just some languages have more powerful meta programming facilities.

In Common Lisp the most common way for the usage of meta programming is through the use of defmacro. Bill Clementson’s Blog post covers Joswig’s use of an embedded DSL in Lisp. Guess what allows him to make such a compact DSL? defmacro of course. Another nice Joswig post on comp.lang.lisp goes through an iterative cycle of design using defmacro.

Benefits and Liabilities of Using The Model

In Fowler’s post he spends about half of it talking about the liabilities of a RulesEngine.The liabilities that he describes are not so dissimilar to the liabilities associated to using Event Collaboration. The benefits are also similar.  At this time I believe it is due to the nature of rules engine and event collaboration are based on graphs. Research on RETE to find the similarites, I think is in order.

+Weak Coupling and High Cohesion. Allows rules and events to evolve without making changes all over system. Does not need to have dependencies between rules or events in order to execute.

+Asynchronous Communications. Any rule or event can be executed at any time or in any order.

-No Implicit Dependencies. It is hard to debug due to complex interactions with loose coupling.

-Duplicated Data and Code. Rules and events can have the proerty of subsumption. In other words more specific rules or events can be taken over by more general rules or events.

Overcoming Liabilities

Comments in this section is welcome

1. Limit set of rules and events.

2. Reduce cyclic triggering of rules and events

3. Testing

4. Tools

5. Utilization of system as soon as possible.

6. Abstraction.

If you liked this you might like this:

Dog-fooding a Domain Specific Language (DSL); creating an extension to Lisp-Unit

Please leave any comments, they will be appreciated.

(defun format-results (result-totals)
  (destructuring-bind (result-totals asserts passes errors elapses) result-totals
    (list
     (format nil "~A Total Test(s)" result-totals)
     (format nil "~A Assertions" asserts)
     (format nil "~A Passes" passes)
     (format nil "~A Failures" (- asserts passes))
     (format nil "~A Errors" errors)
     (format nil "~,3F Second(s)" elapses))))

(defun result-sums (result-totals)
  (loop for (nil assert pass error elapse) in result-totals
        summing assert into asserts
        summing pass into passes
        summing error into errors
        summing elapse into elapses
        finally
        (return
         (list (length result-totals) asserts passes errors elapses))))

(defobj results-model
  (:members ((database nil)))
  (:methods ((:get-result-totals ()
                  (format-results (result-sums (retrieve-totals database))))

             (:connect-db (db)
               (setf database db))

             (:insert-result-data (result-data)
               (add-result database result-data))))

This method really it makes it easier to test the SEF functions. When using the object’s methods for interacting with state during tdd, you have to maintain a reference to the object. By excreting the functionality out of the object, you no longer need the reference. You just test for functionality.

(test-fixture
 :format-results
 (:tests
   (should-return-format-results-empty
    (assert-equal '("0 Total Test(s)" "0 Assertions" "0 Passes" "0 Failures" "0 Errors"
           "0.000 Second(s)") (format-results (list 0 0 0 0 0))))))

(test-fixture
 :result-sums
 (:tests
   (should-return-no-sums
    (assert-equal '(1 0 0 0 0) (result-sums (list (list :no-name 0 0 0 0)))))

   (should-return-sums
    (assert-equal '(2 1 1 1 0.15100001) (result-sums (list (list :t1 0 0 1 0.001) (list :t2 1 1 0 0.15)))))))

(test-fixture
 :results-model
 (:setup ((db (make-database))
          (model (make-results-model)))
   (connect-db model db))
 (:tests
   (should-transmit-result-totals
    (let ((totals '("0 Total Test(s)" "0 Assertions" "0 Passes" "0 Failures" "0 Errors"
           "0.000 Second(s)")))
      (assert-equal totals (get-result-totals model))))

   (should-insert-result-data
    (let ((totals '("1 Total Test(s)" "1 Assertions" "1 Passes" "0 Failures" "0 Errors"
           "0.000 Second(s)")))
      (insert-result-data model (list :no-name 1 1 0 0.0))
      (assert-equal totals (get-result-totals model))))))

This is very conducive to programming incrementally.

The function we want to look at is get-result-totals. This function retrieve the totals from the database. We pass this then to result-sums. It’s results are then passed to format-results.

1. Retrieve results from database.
2. Sum results.
3. Format results.

Happy January!

The last update talked about ‘destructuring-bind‘. I had an epipheny the other day when I was trying to tdd a way to create generic functions for the framework. That led me to throwing away the destructuring-bind.

In order to explain my reasoning we need to go back to the representation of an object in the framework. The representation is a list of closures referenced by properties.

(defun hello (obj &rest args)
  (apply (getf obj :hello) args)

(defvar hold1 (list :hello (lambda () (print 'hello))))
(defvar hold2 (list :hello (lambda (x) (print x))))

The above lists can be accessed with a getf that retrieves the lambda from the list. To execute the lambda just apply. The hello defun above will handle either list as obj.

Something that I now know,  is that the lambda does its own destructuring-bind on its parameter list.  So here is how I create the accessor function for all objects  (generic and multiple signatures):

(defmacro make-property (name)
  (let ((g (gensym)))
    (multiple-value-bind (sym-name key-name) (symbol-and-keyword name)
      `(progn
         (if (not (fboundp ',sym-name))
             (defun ,sym-name (obj &rest ,g)
               (block ,sym-name
                 (apply (getf obj ,key-name) ,g)))))))

Happy New Year!

gutzofter

This little trick hit me when I was perusing PCL. Specifically, the when selector.

(defun rec-cond (key)
  (cond
    ((eq key :before) (format nil "executing before" ))
    ((eq key :during) (format nil "executing during" ))
    ((eq key :after) (format nil "executing after" ))

    ((eq key :set-up) (rec-cond :before))
    ((eq key :init) (rec-cond :before))

    ((eq key :teardown) (rec-cond :after))

    (t (error (format nil "unknown command: ~A" key))))

This overloads keyword symbols so that you more than one keyword can execute the same code.Syntactic Sugar

(defun num (key)
  (cond
    ((eq key :zero) 0)
    ((eq key :one) 1)
    ((eq key :two) (1+ (num :one)))
    ((eq key :three) (1+ (num :two)))
    ((eq key :four) (1+ (num :three)))
    ((eq key :five) (1+ (num :four)))
    ((eq key :six) (1+ (num :five)))
    ((eq key :seven) (1+ (num :six)))
    ((eq key :eight) (1+ (num :seven)))
    ((eq key :nine) (1+ (num :eight)))
    (t (error (format nil "unknown number keyword: ~A" key)))))

(test-fixture
 :num
 (:tests
   (should-do-my-key-numbers
    (assert-equal 0 (num :zero))
    (assert-equal 1 (num :one))
    (assert-equal 2 (num :two))
    (assert-equal 3 (num :three))
    (assert-equal 4 (num :four))
    (assert-equal 5 (num :five))
    (assert-equal 6 (num :six))
    (assert-equal 7 (num :seven))
    (assert-equal 8 (num :eight))
    (assert-equal 9 (num :nine))
    (assert-error 'simple-error (num :haha)))

   (should-do-basic-math
    (assert-equal 5 (+ (num :two) (num :three)))
    (assert-equal 5 (- (num :eight) (num :three)))
    (assert-equal 6 (* (num :two) (num :three)))
    (assert-equal 2 (/ (num :six) (num :three))))))

But who the hell wants to write num function and then keyword.

This might me a little better.

(defmacro with-numbers (&rest rest)
  `(let ((zero 0)
         (one 1)
         (two 2)
         (three 3)
         (four 4)
         (five 5)
         (six 6)
         (seven 7)
         (eight 8)
         (nine 9))
     ,@rest))

(test-fixture
 :num-with-sugar
 (:tests
   (should-use-sugar-number
    (with-numbers
     (assert-equal 0 zero)
     (assert-equal 1 one)
     (assert-equal 2 two)
     (assert-equal 3 three)
     (assert-equal 4 four)
     (assert-equal 5 five)
     (assert-equal 6 six)
     (assert-equal 7 seven)
     (assert-equal 8 eight)
     (assert-equal 9 nine)))

   (should-sugar-do-basic-math
    (with-numbers
     (assert-equal 5 (+ two three))
     (assert-equal 5 (- eight three))
     (assert-equal 6 (* two three))
     (assert-equal 2 (/ six three)))))

I believe that if you use format you can also get something similar. Just intern string to symbol.

(intern (string-upcase (format nil "~r" 0))

I think I’m going to start using different titles for these type of posts.

What do you think?

It is pretty good.

Have Fun!

… binds the variables specified in lambda-list to the corresponding values in the tree structure resulting from the evaluation of expression; then destructuring-bind evaluates forms.

‘destructuring-bind‘ is a wonderful macro. The first thing you do is hand it a lambda list and a list of values. It acts like a pattern matcher. If the list of values does not match up to the lambda list it will throw an error.

Here is what I’m talking about:

(defun test-d-bind (&rest args)
  (destructuring-bind (a &optional (b 3) &rest x &key c (d a)) args
    (list a b c d x))

(test-d-bind nil)
;>>(NIL 3 NIL NIL NIL)
(test-d-bind 1 6 :d 8 :c 9 :d 10)
;>>(1 6 9 8 (:D 8 :C 9 :D 10)

Parameter Keywords

A macro lambda list can contain the lambda list keywords:

&allow-other-keys                 &environment

&rest                             &aux

&key                              &whole

&body                             &optional

An ordinary lambda list can contain the lambda list keywords:

&allow-other-keys                 &key

&rest                             &aux
&optional

The object framework that I’ve been covering couldn’t handle parameter keywords. Now it can. This is all due to destructuring-bind. A very universal macro. I believe that because of this macro I will be able to add generic function for all objects and also multiple function signatures.

(defmacro make-property (name args)
  (let ((g (gensym))
        (r-args (remove-if-not-symbol args)))
    (multiple-value-bind (sym-name key-name) (symbol-and-keyword name)
      `(progn
         (defun ,sym-name (obj &rest ,g)
           (block ,sym-name
             (destructuring-bind ,args ,g
               (declare (ignorable ,@r-args))
               (apply (getf obj ,key-name) ,g)))))))

Future speculation

Generic function and multiple function signatures can be derived from the above code. Looking at the above code we see that the destructuring-bind is embedded within the defun block. Right now we overwrite any previously defun-ed function.

• store ‘args into a list, then using name as key store the list into a hash (args-template table). The ‘args will be considered an instance of a template.
• wrap an error-handler around destructuring-bind and then iterate through the templates to see if a match. If not add to templates table.

Happy Snow Days!

Read It Later

Let q(x) be a property provable about objects x of type T. Then q(y) should be true for objects y of type S where S is a subtype of T.

My Bogus was an attempt to abstract a method by which I could get access to a variable using a syntatic-sugar idiom. The abstraction leaks. Here is how it leaks:

(should-maintain-scope-of-inner-property
       (with-property (value 24)
         (value :is (incf (value))))
       (assert-equal 25 (value)))

‘incf’ is a destructive operation.

Here is a possible implementation of ‘incf’:

(defmacro my-incf (place &optional (val 1))
  (let ((v (gensym))
        (a (gensym)))
    `(let* ((,v ,val)
            (,a (+ ,place ,v)))
       (setf ,place ,a))))

It’s that last form (setf ,place ,a) that breaks the LSP. The only way we can change the actual value of my abstraction is with the keyword symbol :is. So in the end, the operation we were trying to abstract out is what causes the abstraction to leak.

I still think that there is some promise here, it just needs to be pushed on some more.

I would like to thank Zach Beane for his cogent and very lucid comments of why this abstraction was bogus. His very technical discussion was very enlightening. I recommend this also.

References:

On Lisp still amazes me with the amount of information in it. My understanding if ‘incf’ comes from this. Use the on-line version and do searches.

Another nice read is “Technical Issues of Separation in Function Cells and Value Cells”.

If you read Lisp Trick #1, hopefully, you saw a pretty good abstraction. What it was doing was abstracting out the setting and getting a value from a variable. As a bonus, because of the way &key parameter keyword can be used, we were able to differentiate whether you were getting the value or setting the variable. Another bonus is that the variable we are getting and setting is encapsulated.

Usually an abstraction is created with the use of macros. Now I’ve made an even larger abstraction of the setter/getter abstraction.

Here it is:

(defmacro with-property (property &body body)
  (when property
    (let ((p-n (first property)))
      `(let ((,@property))
         (defun ,p-n (&key (is nil is-p))
           (cond
             (is-p (setf ,p-n is))
             (t ,p-n)))
         ,@body))))

(test-fixture
    :with-property-macro
    (:tests
      (should-single-nil-property
       (assert-equal nil (with-property nil)))

      (should-single-property
       (assert-equal 1 (with-property (value 1) value))
       (unintern 'value))

      (should-use-property
       (with-property (value 1)
         (value :is 12))
       (assert-equal 12 (value))
       (value :is 24)
       (assert-equal 24 (value))
       (unintern 'value))

      (should-not-capture-property
       (let ((property 'property))
         (with-property (property 8) property)
         (assert-equal 8 (property)))
       (assert-equal 8 (property))
       (unintern 'property)))

You’ll notice that the scope for the variable remains even after leaving the ‘with-property’ abstraction. Right now I don’t know if that is good or bad. We’ll see.

NOTE: You need to review “And Behind Door Number 2 Is . . .” for an explanation of why this has a leaky abstraction.